html

package
v0.0.0-...-a8ee3e7 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 11, 2022 License: Apache-2.0 Imports: 24 Imported by: 0

Documentation

Index

Examples

Constants

View Source 
const (
	KNewElementIsUndefined = "div.NewDiv().error: new element is undefined:"
	KIdToAppendNotFound    = "html.AppendById().error: id to append not found:"
)

Variables

This section is empty.

Functions

func RGBAToJs 

func RGBAToJs(color color.RGBA) string

RGBAToJs

English: 

Convert the color format color.RGBA to javascript format rgba(R, G, B, A)

Português: 

Converte uma cor em formato color.RGBA para o formato javascript rgba(R, G, B, A)
Example 
colorRGBA := color.RGBA{
	R: 10,
	G: 20,
	B: 30,
	A: 100,
}
fmt.Printf("Color: %v\n", RGBAToJs(colorRGBA))

Output:

Color: rgba( 10, 20, 30, 100 )

func TypeToString 

func TypeToString(value interface{}, separadorA, separadorB string) (ret interface{})

Types

type AdjacentPosition 

type AdjacentPosition string
const (
	// KAdjacentPositionBeforeBegin
	//
	// English:
	//
	//  Before the element. Only valid if the element is in the DOM tree and has a parent element.
	//
	// Português:
	//
	//  Antes do elemento. Válido apenas se o elemento estiver na árvore DOM e tiver um elemento pai.
	KAdjacentPositionBeforeBegin AdjacentPosition = "beforebegin"

	// KAdjacentPositionAfterBegin
	//
	// English:
	//
	//  Just inside the element, before its first child.
	//
	// Português:
	//
	//  Apenas dentro do elemento, antes de seu primeiro filho.
	KAdjacentPositionAfterBegin AdjacentPosition = "afterbegin"

	// KAdjacentPositionBeforeEnd
	//
	// English:
	//
	//  Just inside the element, after its last child.
	//
	// Português:
	//
	//  Apenas dentro do elemento, após seu último filho.
	KAdjacentPositionBeforeEnd AdjacentPosition = "beforeend"

	// KAdjacentPositionAfterEnd
	//
	// english:
	//
	//  After the element. Only valid if the element is in the DOM tree and has a parent element.
	//
	// Português:
	//
	//  Depois do elemento. Válido apenas se o elemento estiver na árvore DOM e tiver um elemento pai.
	KAdjacentPositionAfterEnd AdjacentPosition = "afterend"
)

func (AdjacentPosition) String 

func (e AdjacentPosition) String() string

type Autocomplete 

type Autocomplete string
const (
	// KAutocompleteOff
	//
	// English:
	//
	//  The browser is not permitted to automatically enter or select a value for this field. It is
	//  possible that the document or application provides its own autocomplete feature, or that
	//  security concerns require that the field's value not be automatically entered.
	//
	//   Note:
	//     * In most modern browsers, setting autocomplete to "off" will not prevent a password manager
	//       from asking the user if they would like to save username and password information, or from
	//       automatically filling in those values in a site's login form. See the autocomplete
	//       attribute and login fields.
	//
	// Português:
	//
	//  O navegador não tem permissão para inserir ou selecionar automaticamente um valor para este
	//  campo. É possível que o documento ou aplicativo forneça seu próprio recurso de preenchimento
	//  automático ou que questões de segurança exijam que o valor do campo não seja inserido
	//  automaticamente.
	//
	//   Nota:
	//     * Na maioria dos navegadores modernos, definir o preenchimento automático como "desativado"
	//       não impedirá que um gerenciador de senhas pergunte ao usuário se ele deseja salvar as
	//       informações de nome de usuário e senha ou de preencher automaticamente esses valores no
	//       formulário de login de um site. Consulte o atributo de preenchimento automático e os
	//       campos de login.
	KAutocompleteOff Autocomplete = "off"

	// KAutocompleteOn
	//
	// English:
	//
	//  The browser is allowed to automatically complete the input. No guidance is provided as to the
	//  type of data expected in the field, so the browser may use its own judgement.
	//
	// Português:
	//
	//  O navegador tem permissão para completar automaticamente a entrada. Nenhuma orientação é
	//  fornecida quanto ao tipo de dados esperados no campo, portanto, o navegador pode usar seu
	//  próprio julgamento.
	KAutocompleteOn Autocomplete = "on"

	// KAutocompleteName
	//
	// English:
	//
	//  The field expects the value to be a person's full name. Using "name" rather than breaking the
	//  name down into its components is generally preferred because it avoids dealing with the wide
	//  diversity of human names and how they are structured; however, you can use the following
	//  autocomplete values if you do need to break the name down into its components
	//
	// Português:
	//
	//  O campo espera que o valor seja o nome completo de uma pessoa. Usar "nome" em vez de dividir o
	//  nome em seus componentes é geralmente preferido porque evita lidar com a grande diversidade de
	//  nomes humanos e como eles são estruturados; no entanto, você pode usar os seguintes valores de
	//  preenchimento automático se precisar dividir o nome em seus componentes
	KAutocompleteName Autocomplete = "name"

	// KAutocompleteHonorificPrefix
	//
	// English:
	//
	//  The prefix or title, such as "Mrs.", "Mr.", "Miss", "Ms.", "Dr.", or "Mlle.".
	//
	// Português:
	//
	//  O prefixo ou título, como "Mrs.", "Mr.", "Miss", "Ms.", "Dr." ou "Mlle.".
	KAutocompleteHonorificPrefix Autocomplete = "honorific-prefix"

	// KAutocompleteGivenName
	//
	// English:
	//
	//  The given (or "first") name.
	//
	// Português:
	//
	//  O primeiro nome.
	KAutocompleteGivenName Autocomplete = "given-name"

	// KAutocompleteAdditionalName
	//
	// English:
	//
	//  The middle name.
	//
	// Português:
	//
	//  O nome do meio.
	KAutocompleteAdditionalName Autocomplete = "additional-name"

	// KAutocompleteFamilyName
	//
	// English:
	//
	//  The family (or "last") name.
	//
	// Português:
	//
	//  Sobrenome
	KAutocompleteFamilyName Autocomplete = "family-name"

	// KAutocompleteHonorificSuffix
	//
	// English:
	//
	//  The suffix, such as "Jr.", "B.Sc.", "PhD.", "MBASW", or "IV".
	//
	// Português:
	//
	//  O sufixo, como "Jr.", "B.Sc.", "PhD.", "MBASW" ou "IV".
	KAutocompleteHonorificSuffix Autocomplete = "honorific-suffix"

	// KAutocompleteNickname
	//
	// English:
	//
	//  A nickname or handle.
	//
	// Português:
	//
	//  Um apelido ou identificador.
	KAutocompleteNickname Autocomplete = "nickname"

	// KAutocompleteEmail
	//
	// English:
	//
	//  An email address.
	//
	// Português:
	//
	//  Um endereço de e-mail.
	KAutocompleteEmail Autocomplete = "email"

	// KAutocompleteUsername
	//
	// English:
	//
	//  A username or account name.
	//
	// Português:
	//
	//  Um nome de usuário.
	KAutocompleteUsername Autocomplete = "username"

	// KAutocompleteNewPassword
	//
	// English:
	//
	//  A new password. When creating a new account or changing passwords, this should be used for an
	//  "Enter your new password" or "Confirm new password" field, as opposed to a general "Enter your
	//  current password" field that might be present. This may be used by the browser both to avoid
	//  accidentally filling in an existing password and to offer assistance in creating a secure
	//  password (see also Preventing autofilling with autocomplete="new-password").
	//
	// Português:
	//
	//  Uma nova senha. Ao criar uma nova conta ou alterar senhas, isso deve ser usado para um campo
	//  "Digite sua nova senha" ou "Confirme nova senha", em vez de um campo geral "Digite sua senha
	//  atual" que pode estar presente. Isso pode ser usado pelo navegador tanto para evitar o
	//  preenchimento acidental de uma senha existente quanto para oferecer assistência na criação de
	//  uma senha segura (consulte também Impedindo o preenchimento automático com
	//  autocomplete="new-password").
	KAutocompleteNewPassword Autocomplete = "new-password"

	// KAutocompleteCurrentPassword
	//
	// English:
	//
	//  The user's current password.
	//
	// Português:
	//
	//  A senha atual do usuário.
	KAutocompleteCurrentPassword Autocomplete = "current-password"

	// KAutocompleteOneTimeCode
	//
	// English:
	//
	//  A one-time code used for verifying user identity.
	//
	// Português:
	//
	//  Um código único usado para verificar a identidade do usuário.
	KAutocompleteOneTimeCode Autocomplete = "one-time-code"

	// KAutocompleteOrganizationTitle
	//
	// English:
	//
	//  A job title, or the title a person has within an organization, such as "Senior Technical
	//  Writer", "President", or "Assistant Troop Leader".
	//
	// Português:
	//
	//  Um cargo ou o título que uma pessoa tem dentro de uma organização, como "Escritor Técnico
	//  Sênior", "Presidente" ou "Líder de Tropa Assistente".
	KAutocompleteOrganizationTitle Autocomplete = "organization-title"

	// KAutocompleteOrganization
	//
	// English:
	//
	//  A company or organization name, such as "Acme Widget Company" or "Girl Scouts of America".
	//
	// Português:
	//
	//  Um nome de empresa ou organização, como "Acme Widget Company" ou "Girl Scouts of America".
	KAutocompleteOrganization Autocomplete = "organization"

	// KAutocompleteStreetAddress
	//
	// English:
	//
	//  A street address. This can be multiple lines of text, and should fully identify the location of
	//  the address within its second administrative level (typically a city or town), but should not
	//  include the city name, ZIP or postal code, or country name.
	//
	// Português:
	//
	//  Um endereço de rua. Isso pode ser várias linhas de texto e deve identificar totalmente o local
	//  do endereço em seu segundo nível administrativo (normalmente uma cidade ou vila), mas não deve
	//  incluir o nome da cidade, CEP ou código postal ou nome do país.
	KAutocompleteStreetAddress Autocomplete = "street-address"

	// KAutocompleteAddressLine1
	//
	// English:
	//
	//  Each individual line of the street address. These should only be present if the
	//  "street-address" is not present.
	//
	// Português:
	//
	//  Cada linha individual do endereço. Estes só devem estar presentes se o "endereço" não estiver
	//  presente.
	KAutocompleteAddressLine1 Autocomplete = "address-line1"

	// KAutocompleteAddressLine2
	//
	// English:
	//
	//  Each individual line of the street address. These should only be present if the
	//  "street-address" is not present.
	//
	// Português:
	//
	//  Cada linha individual do endereço. Estes só devem estar presentes se o "endereço" não estiver
	//  presente.
	KAutocompleteAddressLine2 Autocomplete = "address-line2"

	// KAutocompleteAddressLine3
	//
	// English:
	//
	//  Each individual line of the street address. These should only be present if the
	//  "street-address" is not present.
	//
	// Português:
	//
	//  Cada linha individual do endereço. Estes só devem estar presentes se o "endereço" não estiver
	//  presente.
	KAutocompleteAddressLine3 Autocomplete = "address-line3"

	// KAutocompleteAddressLevel4
	//
	// English:
	//
	//  The finest-grained administrative level, in addresses which have four levels.
	//
	// Português:
	//
	//  O nível administrativo mais refinado, em endereços que têm quatro níveis.
	KAutocompleteAddressLevel4 Autocomplete = "address-level4"

	// KAutocompleteAddressLevel3
	//
	// English:
	//
	//  The finest-grained administrative level, in addresses which have four levels.
	//
	// Português:
	//
	//  O nível administrativo mais refinado, em endereços que têm quatro níveis.
	KAutocompleteAddressLevel3 Autocomplete = "address-level3"

	// KAutocompleteAddressLevel2
	//
	// English:
	//
	//  The finest-grained administrative level, in addresses which have four levels.
	//
	// Português:
	//
	//  O nível administrativo mais refinado, em endereços que têm quatro níveis.
	KAutocompleteAddressLevel2 Autocomplete = "address-level2"

	// KAutocompleteAddressLevel1
	//
	// English:
	//
	//  The finest-grained administrative level, in addresses which have four levels.
	//
	// Português:
	//
	//  O nível administrativo mais refinado, em endereços que têm quatro níveis.
	KAutocompleteAddressLevel1 Autocomplete = "address-level1"

	// KAutocompleteCountry
	//
	// English:
	//
	//  A country or territory code.
	//
	// Português:
	//
	//  Um código de país ou território.
	KAutocompleteCountry Autocomplete = "country"

	// KAutocompleteCountryName
	//
	// English:
	//
	//  A country or territory name.
	//
	// Português:
	//
	//  Um nome de país ou território.
	KAutocompleteCountryName Autocomplete = "country-name"

	// KAutocompletePostalCode
	//
	// English:
	//
	//  A postal code (in the United States, this is the ZIP code).
	//
	// Português:
	//
	//  Um código postal (nos Estados Unidos, este é o CEP).
	KAutocompletePostalCode Autocomplete = "postal-code"

	// KAutocompleteCcName
	//
	// English:
	//
	//  The full name as printed on or associated with a payment instrument such as a credit card.
	//  Using a full name field is preferred, typically, over breaking the name into pieces.
	//
	// Português:
	//
	//  O nome completo impresso ou associado a um instrumento de pagamento, como um cartão de crédito.
	//  Normalmente, é preferível usar um campo de nome completo em vez de dividir o nome em partes.
	KAutocompleteCcName Autocomplete = "cc-name"

	// KAutocompleteCcGivenName
	//
	// English:
	//
	//  A given (first) name as given on a payment instrument like a credit card.
	//
	// Português:
	//
	//  Primeiro nome dado em um instrumento de pagamento, como um cartão de crédito.
	KAutocompleteCcGivenName Autocomplete = "cc-given-name"

	// KAutocompleteCcAdditionalName
	//
	// English:
	//
	//  A middle name as given on a payment instrument or credit card.
	//
	// Português:
	//
	//  Nome do meio fornecido em um instrumento de pagamento ou cartão de crédito.
	KAutocompleteCcAdditionalName Autocomplete = "cc-additional-name"

	// KAutocompleteCcFamilyName
	//
	// English:
	//
	//  A family name, as given on a credit card.
	//
	// Português:
	//
	//  Nome de família, conforme fornecido em um cartão de crédito.
	KAutocompleteCcFamilyName Autocomplete = "cc-family-name"

	// KAutocompleteCcNumber
	//
	// English:
	//
	//  A credit card number or other number identifying a payment method, such as an account number.
	//
	// Português:
	//
	//  Um número de cartão de crédito ou outro número que identifique um método de pagamento, como um
	//  número de conta.
	KAutocompleteCcNumber Autocomplete = "cc-number"

	// KAutocompleteCcExp
	//
	// English:
	//
	//  A payment method expiration date, typically in the form "MM/YY" or "MM/YYYY".
	//
	// Português:
	//
	//  Uma data de expiração do método de pagamento, normalmente no formato "MM/YY" ou "MM/YYYY".
	KAutocompleteCcExp Autocomplete = "cc-exp"

	// KAutocompleteCcExpMonth
	//
	// English:
	//
	//  The month in which the payment method expires.
	//
	// Português:
	//
	//  O mês em que a forma de pagamento expira.
	KAutocompleteCcExpMonth Autocomplete = "cc-exp-month"

	// KAutocompleteCcExpYear
	//
	// English:
	//
	//  The year in which the payment method expires.
	//
	// Português:
	//
	//  O ano em que a forma de pagamento expira.
	KAutocompleteCcExpYear Autocomplete = "cc-exp-year"

	// KAutocompleteCcCsc
	//
	// English:
	//
	//  The security code for the payment instrument; on credit cards, this is the 3-digit verification
	//  number on the back of the card.
	//
	// Português:
	//
	//  O código de segurança do instrumento de pagamento; em cartões de crédito, este é o número de
	//  verificação de 3 dígitos no verso do cartão.
	KAutocompleteCcCsc Autocomplete = "cc-csc"

	// KAutocompleteCcType
	//
	// English:
	//
	// The type of payment instrument (such as "Visa" or "Master Card").
	//
	// Português:
	//
	// O tipo de instrumento de pagamento (como "Visa" ou "Master Card").
	KAutocompleteCcType Autocomplete = "cc-type"

	// KAutocompleteTransactionCurrency
	//
	// English:
	//
	//  The currency in which the transaction is to take place.
	//
	// Português:
	//
	//  A moeda em que a transação deve ocorrer.
	KAutocompleteTransactionCurrency Autocomplete = "transaction-currency"

	// KAutocompleteTransactionAmount
	//
	// English:
	//
	//  The amount, given in the currency specified by "transaction-currency", of the transaction,
	//  for a payment form.
	//
	// Português:
	//
	//  O valor, fornecido na moeda especificada por "moeda da transação", da transação, para um
	//  formulário de pagamento.
	KAutocompleteTransactionAmount Autocomplete = "transaction-amount"

	// KAutocompleteLanguage
	//
	// English:
	//
	//  A preferred language, given as a valid BCP 47 language tag.
	//
	// Português:
	//
	//  Um idioma preferencial, fornecido como uma tag de idioma BCP 47 válida.
	KAutocompleteLanguage Autocomplete = "language"

	// KAutocompleteBbday
	//
	// English:
	//
	//  A birth date, as a full date.
	//
	// Português:
	//
	//  Uma data de nascimento, como uma data completa.
	KAutocompleteBbday Autocomplete = "bday"

	// KAutocompleteBdayDay
	//
	// English:
	//
	//  The day of the month of a birth date.
	//
	// Português:
	//
	//  O dia do mês de uma data de nascimento.
	KAutocompleteBdayDay Autocomplete = "bday-day"

	// KAutocompleteBdayMonth
	//
	// English:
	//
	//  The month of the year of a birth date.
	//
	// Português:
	//
	//  O mês do ano de uma data de nascimento.
	KAutocompleteBdayMonth Autocomplete = "bday-month"

	// KAutocompleteBdayYear
	//
	// English:
	//
	//  The year of a birth date.
	//
	// Português:
	//
	//  O ano de uma data de nascimento.
	KAutocompleteBdayYear Autocomplete = "bday-year"

	// KAutocompleteSex
	//
	// English:
	//
	//  A gender identity (such as "Female", "Fa'afafine", "Male"), as freeform text without newlines.
	//
	// Português:
	//
	//  Uma identidade de gênero (como "Feminino", "Fa'afafine", "Masculino"), como texto de forma
	//  livre sem novas linhas.
	KAutocompleteSex Autocomplete = "sex"

	// KAutocompleteTel
	//
	// English:
	//
	//  A full telephone number, including the country code. If you need to break the phone number
	//  up into its components, you can use these values for those fields:
	//
	// Português:
	//
	//  Um número de telefone completo, incluindo o código do país. Se você precisar dividir o número
	//  de telefone em seus componentes, poderá usar estes valores para esses campos:
	KAutocompleteTel Autocomplete = "tel"

	// KAutocompleteTelCountryCode
	//
	// English:
	//
	//  The country code, such as "1" for the United States, Canada, and other areas in North America
	//  and parts of the Caribbean.
	//
	// Português:
	//
	//  O código do país, como "1" para os Estados Unidos, Canadá e outras áreas da América do Norte e
	//  partes do Caribe.
	KAutocompleteTelCountryCode Autocomplete = "tel-country-code"

	// KAutocompleteTelNational
	//
	// English:
	//
	//  The entire phone number without the country code component, including a country-internal
	//  prefix. For the phone number "1-855-555-6502", this field's value would be "855-555-6502".
	//
	// Português:
	//
	//  O número de telefone completo sem o componente de código do país, incluindo um prefixo interno
	//  do país. Para o número de telefone "1-855-555-6502", o valor desse campo seria "855-555-6502".
	KAutocompleteTelNational Autocomplete = "tel-national"

	// KAutocompleteTelAreaCode
	//
	// English:
	//
	//  The area code, with any country-internal prefix applied if appropriate.
	//
	// Português:
	//
	//  O código de área, com qualquer prefixo interno do país aplicado, se apropriado.
	KAutocompleteTelAreaCode Autocomplete = "tel-area-code"

	// KAutocompleteTelLocal
	//
	// English:
	//
	//  The phone number without the country or area code. This can be split further into two parts,
	//  for phone numbers which have an exchange number and then a number within the exchange. For the
	//  phone number "555-6502", use "tel-local-prefix" for "555" and "tel-local-suffix" for "6502".
	//
	// Português:
	//
	//  O número de telefone sem o código do país ou área. Isso pode ser dividido em duas partes, para
	//  números de telefone que têm um número de troca e, em seguida, um número dentro da troca. Para
	//  o número de telefone "555-6502", use "tel-local-prefix" para "555" e "tel-local-suffix"
	//  para "6502".
	KAutocompleteTelLocal Autocomplete = "tel-local"

	// KAutocompleteTelExtension
	//
	// English:
	//
	//  A telephone extension code within the phone number, such as a room or suite number in a hotel
	//  or an office extension in a company.
	//
	// Português:
	//
	//  Um código de ramal de telefone dentro do número de telefone, como um número de quarto ou suíte
	//  em um hotel ou um ramal de escritório em uma empresa.
	KAutocompleteTelExtension Autocomplete = "tel-extension"

	// KAutocompleteImpp
	//
	// English:
	//
	//  A URL for an instant messaging protocol endpoint, such as "xmpp:username@example.net".
	//
	// Português:
	//
	//  Um URL para um terminal de protocolo de mensagens instantâneas, como
	//  "xmpp:username@example.net".
	KAutocompleteImpp Autocomplete = "impp"

	// KAutocompleteUrl
	//
	// English:
	//
	//  A URL, such as a home page or company web site address as appropriate given the context of
	//  the other fields in the form.
	//
	// Português:
	//
	//  Um URL, como uma página inicial ou endereço do site da empresa, conforme apropriado,
	//  considerando o contexto dos outros campos do formulário.
	KAutocompleteUrl Autocomplete = "url"

	// KAutocompletePhoto
	//
	// English:
	//
	//  The URL of an image representing the person, company, or contact information given in the
	//  other fields in the form.
	//
	// Português:
	//
	//  O URL de uma imagem que representa a pessoa, empresa ou informações de contato fornecidas
	//  nos outros campos do formulário.
	KAutocompletePhoto Autocomplete = "photo"
)

func (Autocomplete) String 

func (e Autocomplete) String() string

type ButtonType 

type ButtonType string
const (
	// KButtonTypeSubmit
	//
	// English:
	//
	//  The button submits the form data to the server. This is the default if the attribute is not
	//  specified for buttons associated with a <form>, or if the attribute is an empty or invalid
	//  value.
	//
	// Português:
	//
	//  O botão envia os dados do formulário para o servidor. Este é o padrão se o atributo não for
	//  especificado para botões associados a um <form> ou se o atributo for um valor vazio ou inválido.
	KButtonTypeSubmit ButtonType = "submit"

	// KButtonTypeReset
	//
	// English:
	//
	//  The button resets all the controls to their initial values, like <input type="reset">.
	//  (This behavior tends to annoy users.)
	//
	// Português:
	//
	//  O botão redefine todos os controles para seus valores iniciais, como <input type="reset">.
	//  (Esse comportamento tende a incomodar os usuários.)
	KButtonTypeReset ButtonType = "reset"

	// KButtonTypeButton
	//
	// English:
	//
	//  The button has no default behavior, and does nothing when pressed by default. It can have
	//  client-side scripts listen to the element's events, which are triggered when the events occur.
	//
	// Português:
	//
	//  O botão não tem comportamento padrão e não faz nada quando pressionado por padrão. Ele pode
	//  fazer com que os scripts do lado do cliente escutem os eventos do elemento, que são acionados
	//  quando os eventos ocorrem.
	KButtonTypeButton ButtonType = "button"
)

func (ButtonType) String 

func (e ButtonType) String() string

type CanvasRepeatRule 

type CanvasRepeatRule string
const (
	// KRepeatRuleRepeat
	//
	// English:
	//
	//  (Default) The pattern repeats both horizontally and vertically.
	//
	// Português:
	//
	//  (Padrão) O padrão se repete horizontal e verticalmente.
	KRepeatRuleRepeat CanvasRepeatRule = "repeat"

	// KRepeatRuleRepeatX
	//
	// English:
	//
	//  The pattern repeats only horizontally.
	//
	// Português:
	//
	//  O padrão se repete apenas horizontalmente.
	KRepeatRuleRepeatX CanvasRepeatRule = "repeat-x"

	// KRepeatRuleRepeatY
	//
	// English:
	//
	//  The pattern repeats only vertically.
	//
	// Português:
	//
	//  O padrão se repete apenas verticalmente.
	KRepeatRuleRepeatY CanvasRepeatRule = "repeat-y"

	// KRepeatRuleNoRepeat
	//
	// English:
	//
	//  The pattern will be displayed only once (no repeat).
	//
	// Português:
	//
	//  The pattern will be displayed only once (no repeat).
	KRepeatRuleNoRepeat CanvasRepeatRule = "no-repeat"
)

func (CanvasRepeatRule) String 

func (e CanvasRepeatRule) String() string

type CapRule 

type CapRule string
const (
	// KCapRuleButt
	//
	// English:
	//
	//  (Default) A flat edge is added to each end of the line.
	//
	// Português:
	//
	//  (Padrão) Uma aresta plana é adicionada a cada extremidade da linha.
	KCapRuleButt CapRule = "butt"

	// KCapRuleRound
	//
	// English:
	//
	//  A rounded end cap is added to each end of the line.
	//
	// Português:
	//
	//  Uma tampa de extremidade arredondada é adicionada a cada extremidade da linha.
	KCapRuleRound CapRule = "round"

	// KCapRuleSquare
	//
	// English:
	//
	//  A square end cap is added to each end of the line.
	//
	// Português:
	//
	//  Uma tampa de extremidade quadrada é adicionada a cada extremidade da linha.
	KCapRuleSquare CapRule = "square"
)

func (CapRule) String 

func (e CapRule) String() string

type Compatible 

type Compatible interface {
	Get() js.Value
}

type CompositeOperationsRule 

type CompositeOperationsRule string
const (
	// KCompositeOperationsRuleSourceOver
	//
	// English:
	//
	//  (Default) Displays the source image over the destination image.
	//
	// Português:
	//
	//  (Padrão) Exibe a imagem de origem sobre a imagem de destino.
	KCompositeOperationsRuleSourceOver CompositeOperationsRule = "source-over"

	// KCompositeOperationsRuleSourceAtop
	//
	// English:
	//
	//  Displays the source image on top of the destination image. The part of the source image that is
	//  outside the destination image is not shown.
	//
	// Português:
	//
	//  Exibe a imagem de origem sobre a imagem de destino. A parte da imagem de origem que está fora
	//  da imagem de destino não é mostrada.
	KCompositeOperationsRuleSourceAtop CompositeOperationsRule = "source-atop"

	// KCompositeOperationsRuleSourceIn
	//
	// English:
	//
	//  Displays the source image in to the destination image. Only the part of the source image that is
	//  INSIDE the destination image is shown, and the destination image is transparent.
	//
	// Português:
	//
	//  Exibe a imagem de origem na imagem de destino. Apenas a parte da imagem de origem que está
	//  DENTRO da imagem de destino é mostrada, e a imagem de destino é transparente.
	KCompositeOperationsRuleSourceIn CompositeOperationsRule = "source-in"

	// KCompositeOperationsRuleSourceOut
	//
	// English:
	//
	//  Displays the source image out of the destination image. Only the part of the source image that
	//  is OUTSIDE the destination image is shown, and the destination image is transparent.
	//
	// Português:
	//
	//  Exibe a imagem de origem fora da imagem de destino. Apenas a parte da imagem de origem que está
	//  FORA da imagem de destino é mostrada, e a imagem de destino é transparente.
	KCompositeOperationsRuleSourceOut CompositeOperationsRule = "source-out"

	// KCompositeOperationsRuleDestinationOver
	//
	// English:
	//
	//  Displays the destination image over the source image.
	//
	// Português:
	//
	//  Exibe a imagem de destino sobre a imagem de origem.
	KCompositeOperationsRuleDestinationOver CompositeOperationsRule = "destination-over"

	// KCompositeOperationsRuleDestinationAtop
	//
	// English:
	//
	//  Displays the destination image on top of the source image. The part of the destination image
	//  that is outside the source image is not shown.
	//
	// Português:
	//
	//  Exibe a imagem de destino sobre a imagem de origem. A parte da imagem de destino que está fora
	//  da imagem de origem não é mostrada.
	KCompositeOperationsRuleDestinationAtop CompositeOperationsRule = "destination-atop"

	// KCompositeOperationsRuleDestinationIn
	//
	// English:
	//
	//  Displays the destination image in to the source image. Only the part of the destination image
	//  that is INSIDE the source image is shown, and the source image is transparent.
	//
	// Português:
	//
	//  Exibe a imagem de destino na imagem de origem. Apenas a parte da imagem de destino que está
	//  DENTRO da imagem de origem é mostrada, e a imagem de origem é transparente.
	KCompositeOperationsRuleDestinationIn CompositeOperationsRule = "destination-in"

	// KCompositeOperationsRuleDestinationOut
	//
	// English:
	//
	//  Displays the destination image out of the source image. Only the part of the destination image
	//  that is OUTSIDE the source image is shown, and the source image is transparent.
	//
	// Português:
	//
	//  Exibe a imagem de destino fora da imagem de origem. Apenas a parte da imagem de destino que está
	//  FORA da imagem de origem é mostrada, e a imagem de origem é transparente.
	KCompositeOperationsRuleDestinationOut CompositeOperationsRule = "destination-out"

	// KCompositeOperationsRuleLighter
	//
	// English:
	//
	//  Displays the source image + the destination image.
	//
	// Português:
	//
	//  Exibe a imagem de origem + a imagem de destino.
	KCompositeOperationsRuleLighter CompositeOperationsRule = "lighter"

	// KCompositeOperationsRuleCopy
	//
	// English:
	//
	//  Displays the source image. The destination image is ignored.
	//
	// Português:
	//
	//  Exibe a imagem de origem. A imagem de destino é ignorada.
	KCompositeOperationsRuleCopy CompositeOperationsRule = "copy"

	// KCompositeOperationsRuleXor
	//
	// English:
	//
	//  The source image is combined by using an exclusive OR with the destination image.
	//
	// Português:
	//
	//  A imagem de origem é combinada usando um OR exclusivo com a imagem de destino.
	KCompositeOperationsRuleXor CompositeOperationsRule = "xor"
)

func (CompositeOperationsRule) String 

func (e CompositeOperationsRule) String() string

type ControlPoint 

type ControlPoint struct {
	// contains filtered or unexported fields
}

ControlPoint

English:

Each control point description is a set of four values: x1 y1 x2 y2, describing the Bézier control points for one time segment. The keyTimes values that define the associated segment are the Bézier "anchor points", and the keySplines values are the control points. Thus, there must be one fewer sets of control points than there are keyTimes.

The values of x1 y1 x2 y2 must all be in the range 0 to 1.

Português:

Cada descrição de ponto de controle é um conjunto de quatro valores: x1 y1 x2 y2, descrevendo os pontos de controle Bézier para um segmento de tempo. Os valores de keyTimes que definem o segmento associado são os "pontos de ancoragem" de Bézier, e os valores de keySplines são os pontos de controle. Assim, deve haver um conjunto de pontos de controle a menos do que keyTimes.

Os valores de x1 y1 x2 y2 devem estar todos no intervalo de 0 a 1.

func (*ControlPoint) Add 

func (e *ControlPoint) Add(x1, y1, x2, y2 float64)

func (ControlPoint) String 

func (e ControlPoint) String() string

type CrossOrigin 

type CrossOrigin string
const (
	// KCrossOriginAnonymous
	//
	// English:
	//
	//  A CORS request is sent with credentials omitted (that is, no cookies, X.509 certificates, or
	//  Authorization request header).
	//
	// Português:
	//
	//  Uma solicitação CORS é enviada com credenciais omitidas (ou seja, sem cookies, certificados
	//  X.509 ou cabeçalho de solicitação de autorização).
	KCrossOriginAnonymous CrossOrigin = "anonymous"

	// KCrossOriginUseCredentials
	//
	// English:
	//
	//  The CORS request is sent with any credentials included (that is, cookies, X.509 certificates,
	//  and the Authorization request header).
	//
	// If the server does not opt into sharing credentials with the origin site (by sending back the
	// Access-Control-Allow-Credentials: true response header), then the browser marks the image as
	// tainted and restricts access to its image data.
	//
	// If the attribute has an invalid value, browsers handle it as if the anonymous value was used.
	// See CORS settings attributes for additional information.
	//
	// Português:
	//
	//  A solicitação CORS é enviada com todas as credenciais incluídas (ou seja, cookies, certificados
	//  X.509 e o cabeçalho da solicitação de autorização).
	//
	// Se o servidor não optar por compartilhar credenciais com o site de origem (enviando de volta o
	// cabeçalho Access-Control-Allow-Credentials: true response), o navegador marcará a imagem como
	// contaminada e restringirá o acesso aos dados da imagem.
	//
	// Se o atributo tiver um valor inválido, os navegadores o tratarão como se o valor anônimo fosse
	// usado. Consulte Atributos de configurações do CORS para obter informações adicionais.
	KCrossOriginUseCredentials CrossOrigin = "use-credentials"
)

func (CrossOrigin) String 

func (e CrossOrigin) String() string

type Decoding 

type Decoding string
const (
	// KDecodingSync
	//
	// English:
	//
	//  Decode the image synchronously, for atomic presentation with other content.
	//
	// Português:
	//
	//  Decodifique a imagem de forma síncrona, para apresentação atômica com outro conteúdo.
	KDecodingSync Decoding = "sync"

	// KDecodingAsync
	//
	// English:
	//
	//  Decode the image asynchronously, to reduce delay in presenting other content.
	//
	// Português:
	//
	//  Decodifique a imagem de forma assíncrona, para reduzir o atraso na apresentação de outros
	//  conteúdos.
	KDecodingAsync Decoding = "async"

	// KDecodingAuto
	//
	// English:
	//
	//  No preference for the decoding mode. The browser decides what is best for the user. (Default)
	//
	// Português:
	//
	//  Sem preferência para o modo de decodificação. O navegador decide o que é melhor para o usuário.
	//  (Padrão)
	KDecodingAuto Decoding = "auto"
)

func (Decoding) String 

func (e Decoding) String() string

type Degrees 

type Degrees float64

func (*Degrees) GetRad 

func (e *Degrees) GetRad() (radians float64)

func (*Degrees) SetRad 

func (e *Degrees) SetRad(value float64)

func (Degrees) String 

func (e Degrees) String() string
Example 
a := Degrees(-65)
fmt.Printf("%v", a)

Output:

-65deg

type Dir 

type Dir string

Dir

English: 

Specifies the text direction for the content in an element.

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

const (
	// KDirLeftToRight
	//
	// English:
	//
	//  Default. Left-to-right text direction.
	//
	// Português:
	//
	//  Padrão. Direção do texto da esquerda para a direita.
	KDirLeftToRight Dir = "ltr"

	// KDirRightToLeft
	//
	// English:
	//
	//  Right-to-left text direction.
	//
	// Português:
	//
	//  Direção do texto da direita para a esquerda.
	KDirRightToLeft Dir = "rtl"

	// KDirAuto
	//
	// English:
	//
	//  Let the browser figure out the text direction, based on the content (only recommended if the
	//  text direction is unknown)
	//
	// Português:
	//
	//  Deixe o navegador descobrir a direção do texto, com base no conteúdo (recomendado apenas se a
	//  direção do texto for desconhecida)
	KDirAuto Dir = "auto"
)

func (Dir) String 

func (e Dir) String() (element string)

type Draggable 

type Draggable string

Draggable

English: 

Specifies whether an element is draggable or not

Português: 

Especifica se um elemento pode ser arrastado ou não

const (
	// KDraggableYes
	//
	// English:
	//
	//  Specifies that the element is draggable.
	//
	// Português:
	//
	//  Especifica que o elemento pode ser arrastado.
	KDraggableYes Draggable = "true"

	// KDraggableNo
	//
	// English:
	//
	//  Specifies that the element is not draggable.
	//
	// Português:
	//
	//  Especifica que o elemento não pode ser arrastado.
	KDraggableNo Draggable = "false"

	// KDraggableAuto
	//
	// English:
	//
	//  Uses the default behavior of the browser.
	//
	// Português:
	//
	//  Usa o comportamento padrão do navegador.
	KDraggableAuto Draggable = "auto"
)

func (Draggable) String 

func (e Draggable) String() (element string)

type EnterKeyHint 

type EnterKeyHint string
const (
	// EnterKeyHintEnter
	//
	// English:
	//
	//  typically indicating inserting a new line.
	//
	// Português:
	//
	//  normalmente indicando a inserção de uma nova linha.
	EnterKeyHintEnter EnterKeyHint = "enter"

	// EnterKeyHintDone
	//
	// English:
	//
	//  Typically meaning there is nothing more to input and the input method editor (IME) will be
	//  closed.
	//
	// Português:
	//
	//  Normalmente, significa que não há mais nada para inserir e o editor de método de entrada (IME)
	//  será fechado.
	EnterKeyHintDone EnterKeyHint = "done"

	// EnterKeyHintGo
	//
	// English:
	//
	//  Typically meaning to take the user to the target of the text they typed.
	//
	// Português:
	//
	//  Normalmente significa levar o usuário ao destino do texto digitado.
	EnterKeyHintGo EnterKeyHint = "go"

	// EnterKeyHintNext
	//
	// English:
	//
	//  Typically taking the user to the next field that will accept text.
	//
	// Português:
	//
	//  Normalmente levando o usuário para o próximo campo que aceitará texto.
	EnterKeyHintNext EnterKeyHint = "next"

	// EnterKeyHintPrevious
	//
	// English:
	//
	//  Typically taking the user to the previous field that will accept text.
	//
	// Português:
	//
	//  Normalmente levando o usuário ao campo anterior que aceitará texto.
	EnterKeyHintPrevious EnterKeyHint = "previous"

	// EnterKeyHintSearch
	//
	// English:
	//
	//  Typically taking the user to the results of searching for the text they have typed.
	//
	// Português:
	//
	//  Normalmente, leva o usuário aos resultados da pesquisa do texto que digitou.
	EnterKeyHintSearch EnterKeyHint = "search"

	// EnterKeyHintSend
	//
	// English:
	//
	//  Typically delivering the text to its target.
	//
	// Português:
	//
	//  Normalmente entregando o texto ao seu destino.
	EnterKeyHintSend EnterKeyHint = "send"
)

func (EnterKeyHint) String 

func (e EnterKeyHint) String() string

type FetchPriority 

type FetchPriority string
const (
	// KFetchPriorityHigh
	//
	// English:
	//
	//  Signals a high-priority fetch relative to other images.
	//
	// Português:
	//
	//  Sinaliza uma busca de alta prioridade em relação a outras imagens.
	KFetchPriorityHigh FetchPriority = "high"

	// KFetchPriorityLow
	//
	// English:
	//
	//  Signals a low-priority fetch relative to other images.
	//
	// Português:
	//
	//  Sinaliza uma busca de baixa prioridade em relação a outras imagens.
	KFetchPriorityLow FetchPriority = "low"

	// KFetchPriorityAuto
	//
	// English:
	//
	//  Signals automatic determination of fetch priority relative to other images.
	//
	// Português:
	//
	//  Sinaliza a determinação automática da prioridade de busca em relação a outras imagens.
	KFetchPriorityAuto FetchPriority = "auto"
)

func (FetchPriority) String 

func (e FetchPriority) String() string

type FillRule 

type FillRule string
const (
	// KFillRuleNonZero
	//
	// English:
	//
	//  In two-dimensional computer graphics, the non-zero winding rule is a means of determining
	//  whether a given point falls within an enclosed curve. Unlike the similar even-odd rule, it
	//  relies on knowing the direction of stroke for each part of the curve.
	//
	// Português:
	//
	//  Em computação gráfica bidimensional, a regra de enrolamento diferente de zero é um meio de
	//  determinar se um determinado ponto está dentro de uma curva fechada. Ao contrário da regra
	//  par-ímpar semelhante, ela depende do conhecimento da direção do curso para cada parte da curva.
	KFillRuleNonZero FillRule = "nonzero"

	// KFillRuleEvenOdd
	//
	// English:
	//
	//  The even–odd rule is an algorithm implemented in vector-based graphic software,[1] like the
	//  PostScript language and Scalable Vector Graphics (SVG), which determines how a graphical shape
	//  with more than one closed outline will be filled. Unlike the nonzero-rule algorithm, this
	//  algorithm will alternatively color and leave uncolored shapes defined by nested closed paths
	//  irrespective of their winding.
	//
	// Português:
	//
	//  A regra par-ímpar é um algoritmo implementado em software gráfico baseado em vetor,[1] como a
	//  linguagem PostScript e Scalable Vector Graphics (SVG), que determina como uma forma gráfica com
	//  mais de um contorno fechado será preenchida. Ao contrário do algoritmo de regra diferente de
	//  zero, esse algoritmo alternadamente colorirá e deixará formas não coloridas definidas por
	//  caminhos fechados aninhados, independentemente de seu enrolamento.
	KFillRuleEvenOdd FillRule = "evenodd"
)

func (FillRule) String 

func (e FillRule) String() string

type Font 

type Font struct {
	//Style
	//
	// English:
	//
	//  Specifies the font style.
	//
	// Português:
	//
	//  Especifica o estilo da fonte.
	Style FontStyleRule

	// Variant
	//
	// English:
	//
	//  Specifies the font variant.
	//
	// Português:
	//
	//  Especifica a variante da fonte.
	Variant FontVariantRule

	// Weight
	//
	// English:
	//
	//  Specifies the font weight.
	//
	// Português:
	//
	//  Especifica o peso da fonte.
	Weight FontWeightRule

	// Size
	//
	// English:
	//
	//  Specifies the font size and the line-height, in pixels.
	//
	// Português:
	//
	//  Especifica o tamanho da fonte e a altura da linha, em pixels.
	Size int

	// Family
	//
	// English:
	//
	//  Specifies the font family.
	//
	// Português:
	//
	//  Especifica a família de fontes.
	Family string

	// Caption
	//
	// English:
	//
	//  Use the font captioned controls (like buttons, drop-downs, etc.)
	//
	// Português:
	//
	//  Use os controles legendados de fonte (como botões, menus suspensos etc.)
	Caption string

	// Icon
	//
	// English:
	//
	//  Use the font used to label icons.
	//
	// Português:
	//
	//  Use a fonte usada para rotular os ícones.
	Icon string

	// Menu
	//
	// English:
	//
	//  Use the font used in menus (drop-down menus and menu lists).
	//
	// Português:
	//
	//  Use a fonte usada nos menus (menus suspensos e listas de menus).
	Menu string

	// MessageBox
	//
	// English:
	//
	//  Use the font used in dialog boxes.
	//
	// Português:
	//
	//  Use a fonte usada nas caixas de diálogo.
	MessageBox string

	// SmallCaption
	//
	// English:
	//
	//  Use the font used for labeling small controls.
	//
	// Português:
	//
	//  Use a fonte usada para rotular pequenos controles.
	SmallCaption string

	// StatusBar
	//
	// English:
	//
	//  Use the fonts used in window status bar.
	//
	// Português:
	//
	//  Use as fontes usadas na barra de status da janela.
	StatusBar string
}

func (*Font) String 

func (e *Font) String() string

type FontAlignRule 

type FontAlignRule string
const (
	// KFontAlignRuleStart
	//
	// English:
	//
	//  (Default) The text starts at the specified position.
	//
	// Português:
	//
	//  (Padrão) O texto começa na posição especificada.
	KFontAlignRuleStart FontAlignRule = "start"

	// KFontAlignRuleEnd
	//
	// English:
	//
	//  The text ends at the specified position.
	//
	// Português:
	//
	//  O texto termina na posição especificada.
	KFontAlignRuleEnd FontAlignRule = "end"

	// KFontAlignRuleCenter
	//
	// English:
	//
	//  The center of the text is placed at the specified position.
	//
	// Português:
	//
	//  O centro do texto é colocado na posição especificada.
	KFontAlignRuleCenter FontAlignRule = "center"

	// KFontAlignRuleLeft
	//
	// English:
	//
	//  The text starts at the specified position.
	//
	// Português:
	//
	//  O texto começa na posição especificada.
	KFontAlignRuleLeft FontAlignRule = "left"

	// KFontAlignRuleRight
	//
	// English:
	//
	//  The text ends at the specified position.
	//
	// Português:
	//
	//  O texto termina na posição especificada.
	KFontAlignRuleRight FontAlignRule = "right"
)

func (FontAlignRule) String 

func (e FontAlignRule) String() string

type FontStyleRule 

type FontStyleRule string
const (
	// KFontStyleRuleNormal
	//
	// English:
	//
	//  Specifies the font style normal.
	//
	// Português:
	//
	//  Especifica o estilo de fonte normal.
	KFontStyleRuleNormal FontStyleRule = "normal"

	// KFontStyleRuleItalic
	//
	// English:
	//
	//  Specifies the font style italic.
	//
	// Português:
	//
	//  Especifica o estilo de fonte em itálico.
	KFontStyleRuleItalic FontStyleRule = "italic"

	// KFontStyleRuleOblique
	//
	// English:
	//
	//  Specifies the font style oblique.
	//
	// Português:
	//
	//  Especifica o estilo de fonte oblíquo.
	KFontStyleRuleOblique FontStyleRule = "oblique"
)

func (FontStyleRule) String 

func (e FontStyleRule) String() string

type FontVariantRule 

type FontVariantRule string
const (
	// KFontVariantRuleNormal
	//
	// English:
	//
	//  Specifies the font variant normal.
	//
	// Português:
	//
	//  Especifica a variante de fonte normal.
	KFontVariantRuleNormal FontVariantRule = "normal"

	// KFontVariantRuleSmallCaps
	//
	// English:
	//
	//  Specifies the font variant small-caps.
	//
	// Português:
	//
	//  Especifica as letras minúsculas da variante da fonte.
	KFontVariantRuleSmallCaps FontVariantRule = "small-caps"
)

func (FontVariantRule) String 

func (e FontVariantRule) String() string

type FontWeightRule 

type FontWeightRule string
const (
	// KFontWeightRuleNormal
	//
	// English:
	//
	//  Specifies the font weight normal.
	//
	// Português:
	//
	//  Especifica o peso da fonte normal.
	KFontWeightRuleNormal FontWeightRule = "normal"

	// KFontWeightRuleBold
	//
	// English:
	//
	//  Specifies the font weight bold.
	//
	// Português:
	//
	//  Especifica a espessura da fonte em negrito.
	KFontWeightRuleBold FontWeightRule = "bold"

	// KFontWeightRuleBolder
	//
	// English:
	//
	//  Specifies the font weight bolder.
	//
	// Português:
	//
	//  Especifica o peso da fonte em negrito.
	KFontWeightRuleBolder FontWeightRule = "bolder"

	// KFontWeightRuleLighter
	//
	// English:
	//
	//  Specifies the font weight lighter.
	//
	// Português:
	//
	//  Especifica o peso da fonte mais leve.
	KFontWeightRuleLighter FontWeightRule = "lighter"

	// KFontWeightRule100
	//
	// English:
	//
	//  Specifies the font weight 100.
	//
	// Português:
	//
	//  Especifica o peso da fonte 100.
	KFontWeightRule100 FontWeightRule = "100"

	// KFontWeightRule200
	//
	// English:
	//
	//  Specifies the font weight 200.
	//
	// Português:
	//
	//  Especifica o peso da fonte 200.
	KFontWeightRule200 FontWeightRule = "200"

	// KFontWeightRule300
	//
	// English:
	//
	//  Specifies the font weight 300.
	//
	// Português:
	//
	//  Especifica o peso da fonte 300.
	KFontWeightRule300 FontWeightRule = "300"

	// KFontWeightRule400
	//
	// English:
	//
	//  Specifies the font weight 400.
	//
	// Português:
	//
	//  Especifica o peso da fonte 400.
	KFontWeightRule400 FontWeightRule = "400"

	// KFontWeightRule500
	//
	// English:
	//
	//  Specifies the font weight 500.
	//
	// Português:
	//
	//  Especifica o peso da fonte 500.
	KFontWeightRule500 FontWeightRule = "500"

	// KFontWeightRule600
	//
	// English:
	//
	//  Specifies the font weight 600.
	//
	// Português:
	//
	//  Especifica o peso da fonte 600.
	KFontWeightRule600 FontWeightRule = "600"

	// KFontWeightRule700
	//
	// English:
	//
	//  Specifies the font weight 700.
	//
	// Português:
	//
	//  Especifica o peso da fonte 700.
	KFontWeightRule700 FontWeightRule = "700"

	// KFontWeightRule800
	//
	// English:
	//
	//  Specifies the font weight 800.
	//
	// Português:
	//
	//  Especifica o peso da fonte 800.
	KFontWeightRule800 FontWeightRule = "800"

	// KFontWeightRule900
	//
	// English:
	//
	//  Specifies the font weight 900.
	//
	// Português:
	//
	//  Especifica o peso da fonte 900.
	KFontWeightRule900 FontWeightRule = "900"
)

func (FontWeightRule) String 

func (e FontWeightRule) String() string

type FormEncType 

type FormEncType string
const (
	// KFormEncTypeApplication
	//
	// English:
	//
	//  The default if the attribute is not used.
	//
	// Português:
	//
	//  O padrão se o atributo não for usado.
	KFormEncTypeApplication FormEncType = "application/x-www-form-urlencoded"

	// KFormEncTypeMultiPart
	//
	// English:
	//
	//  Use to submit <input> elements with their type attributes set to file.
	//
	// Português:
	//
	//  Use para enviar elementos <input> com seus atributos de tipo definidos para arquivo.
	KFormEncTypeMultiPart FormEncType = "multipart/form-data"

	// KFormEncTypeText
	//
	// English:
	//
	//  Specified as a debugging aid; shouldn't be used for real form submission.
	//
	// Português:
	//
	//  Especificado como auxiliar de depuração; não deve ser usado para envio de formulário real.
	KFormEncTypeText FormEncType = "text/plain"
)

func (FormEncType) String 

func (e FormEncType) String() string

type FormMethod 

type FormMethod string
const (
	// KFormMethodPost
	//
	// English:
	//
	//  The data from the form are included in the body of the HTTP request when sent to the server.
	//  Use when the form contains information that shouldn't be public, like login credentials.
	//
	// Português:
	//
	//  Os dados do formulário são incluídos no corpo da solicitação HTTP quando enviados ao servidor.
	//  Use quando o formulário contém informações que não devem ser públicas, como credenciais de
	//  login.
	KFormMethodPost FormMethod = "post"

	// KFormMethodGet
	//
	// English:
	//
	//  The form data are appended to the form's action URL, with a ? as a separator, and the resulting
	//  URL is sent to the server. Use this method when the form has no side effects, like search forms.
	//
	// Português:
	//
	//  Os dados do formulário são anexados à URL de ação do formulário, com um ? como separador e a URL
	//  resultante é enviada ao servidor. Use este método quando o formulário não tiver efeitos
	//  colaterais, como formulários de pesquisa.
	KFormMethodGet FormMethod = "get"

	// KFormMethodDialog
	//
	// English:
	//
	//  When the form is inside a <dialog>, closes the dialog and throws a submit event on submission
	//  without submitting data or clearing the form.
	//
	// Português:
	//
	//  When the form is inside a <dialog>, closes the dialog and throws a submit event on submission
	//  without submitting data or clearing the form.
	KFormMethodDialog FormMethod = "dialog"
)

func (FormMethod) String 

func (e FormMethod) String() string

type InputMode 

type InputMode string
const (
	// KInputModeNone
	//
	// English:
	//
	//  No virtual keyboard. For when the page implements its own keyboard input control.
	//
	// Português:
	//
	//  Sem teclado virtual. Para quando a página implementa seu próprio controle de entrada de teclado.
	KInputModeNone InputMode = "none"

	// KInputModeText
	//
	// English:
	//
	//   Standard input keyboard for the user's current locale. (default)
	//
	// Português:
	//
	//  Teclado de entrada padrão para a localidade atual do usuário. (Padrão)
	KInputModeText InputMode = "text"

	// KInputModeDecimal
	//
	// English:
	//
	//  Fractional numeric input keyboard containing the digits and decimal separator for the user's
	//  locale (typically . or ,). Devices may or may not show a minus key (-).
	//
	// Português:
	//
	//  Teclado de entrada numérica fracionária contendo os dígitos e o separador decimal para a
	//  localidade do usuário (normalmente . ou ,). Os dispositivos podem ou não mostrar uma tecla
	//  de menos (-).
	KInputModeDecimal InputMode = "decimal"

	// KInputModeNumeric
	//
	// English:
	//
	//  Numeric input keyboard, but only requires the digits 0–9. Devices may or may not show a minus
	//  key.
	//
	// Português:
	//
	//  Teclado de entrada numérica, mas requer apenas os dígitos de 0 a 9. Os dispositivos podem ou
	//  não mostrar uma tecla de menos.
	KInputModeNumeric InputMode = "numeric"

	// KInputModeTel
	//
	// English:
	//
	//  A telephone keypad input, including the digits 0–9, the asterisk (*), and the pound (#) key.
	//  Inputs that *require* a telephone number should typically use <input type="tel"> instead.
	//
	// Português:
	//
	//  Uma entrada do teclado do telefone, incluindo os dígitos de 0 a 9, o asterisco (*) e a tecla
	//  sustenido (#). As entradas que exigem um número de telefone normalmente devem usar
	//  <input type="tel">.
	KInputModeTel InputMode = "tel"

	// KInputModeSearch
	//
	// English:
	//
	//  A virtual keyboard optimized for search input. For instance, the return/submit key may be
	//  labeled "Search", along with possible other optimizations. Inputs that require a search query
	//  should typically use <input type="search"> instead.
	//
	// Português:
	//
	//  Um teclado virtual otimizado para entrada de pesquisa. Por exemplo, a chave returnsubmit pode
	//  ser rotulada como "Search", juntamente com possíveis outras otimizações. As entradas que exigem
	//  uma consulta de pesquisa normalmente devem usar <input type="search">.
	KInputModeSearch InputMode = "search"

	// KInputModeEmail
	//
	// English:
	//
	//  A virtual keyboard optimized for entering email addresses. Typically includes the @character
	//  as well as other optimizations. Inputs that require email addresses should typically use
	//  <input type="email"> instead.
	//
	// Português:
	//
	//  Um teclado virtual otimizado para inserir endereços de e-mail. Normalmente inclui o @character,
	//  bem como outras otimizações. As entradas que exigem endereços de e-mail normalmente devem usar
	//  <input type="email">.
	KInputModeEmail InputMode = "email"

	// KInputModeUrl
	//
	// English:
	//
	//  A keypad optimized for entering URLs. This may have the / key more prominent, for example.
	//  Enhanced features could include history access and so on. Inputs that require a URL should
	//  typically use <input type="url"> instead.
	//
	// Português:
	//
	//  Um teclado otimizado para inserir URLs. Isso pode ter a chave mais proeminente, por exemplo.
	//  Recursos aprimorados podem incluir acesso ao histórico e assim por diante. As entradas que
	//  exigem um URL normalmente devem usar <input type="url">.
	KInputModeUrl InputMode = "url"
)

func (InputMode) String 

func (e InputMode) String() string

type InputType 

type InputType string
const (
	// KInputTypeButton
	//
	// English:
	//
	//  A push button with no default behavior displaying the value of the value attribute, empty by
	//  default.
	//
	// Português:
	//
	//  Um botão de ação sem comportamento padrão exibindo o valor do atributo value, vazio por padrão.
	KInputTypeButton InputType = "button"

	// KInputTypeCheckbox
	//
	// English:
	//
	//  A check box allowing single values to be selected/deselected.
	//
	// Português:
	//
	//  Uma caixa de seleção que permite que valores únicos sejam selecionados desmarcados.
	KInputTypeCheckbox InputType = "checkbox"

	// KInputTypeColor
	//
	// English:
	//
	//  A control for specifying a color; opening a color picker when active in supporting browsers.
	//
	// Português:
	//
	//  Um controle para especificar uma cor; abrindo um seletor de cores quando ativo em navegadores
	//  compatíveis.
	KInputTypeColor InputType = "color"

	// KInputTypeDate
	//
	// English:
	//
	//  A control for entering a date (year, month, and day, with no time). Opens a date picker or
	//  numeric wheels for year, month, day when active in supporting browsers.
	//
	// Português:
	//
	//  Um controle para inserir uma data (ano, mês e dia, sem hora). Abre um seletor de data ou rodas
	//  numéricas para ano, mês, dia quando ativo em navegadores compatíveis.
	KInputTypeDate InputType = "date"

	// KInputTypeDatetimeLocal
	//
	// English:
	//
	//  A control for entering a date and time, with no time zone. Opens a date picker or numeric
	//  wheels for date- and time-components when active in supporting browsers.
	//
	// Português:
	//
	//  Um controle para inserir uma data e hora, sem fuso horário. Abre um seletor de data ou rodas
	//  numéricas para componentes de data e hora quando ativo em navegadores compatíveis.
	KInputTypeDatetimeLocal InputType = "datetime-local"

	// KInputTypeEmail
	//
	// English:
	//
	//  A field for editing an email address. Looks like a text input, but has validation parameters and
	//  relevant keyboard in supporting browsers and devices with dynamic keyboards.
	//
	// Português:
	//
	//  Um campo para editar um endereço de e-mail. Parece uma entrada de texto, mas possui parâmetros
	//  de validação e teclado relevante no suporte a navegadores e dispositivos com teclados dinâmicos.
	KInputTypeEmail InputType = "email"

	// KInputTypeFile
	//
	// English:
	//
	//  A control that lets the user select a file. Use the accept attribute to define the types of
	//  files that the control can select.
	//
	// Português:
	//
	//  Um controle que permite ao usuário selecionar um arquivo. Use o atributo accept para definir os
	//  tipos de arquivos que o controle pode selecionar.
	KInputTypeFile InputType = "file"

	// KInputTypeHidden
	//
	// English:
	//
	//  A control that is not displayed but whose value is submitted to the server. There is an example
	//  in the next column, but it's hidden!
	//
	// Português:
	//
	//  Um controle que não é exibido, mas cujo valor é enviado ao servidor. Há um exemplo na próxima
	//  coluna, mas está oculto!
	KInputTypeHidden InputType = "hidden"

	// KInputTypeImage
	//
	// English:
	//
	//  A graphical submit button. Displays an image defined by the src attribute. The alt attribute
	//  displays if the image src is missing.
	//
	// Português:
	//
	//  Um botão de envio gráfico. Exibe uma imagem definida pelo atributo src. O atributo alt é
	//  exibido se o src da imagem estiver ausente.
	KInputTypeImage InputType = "image"

	// KInputTypeMonth
	//
	// English:
	//
	//  A control for entering a month and year, with no time zone.
	//
	// Português:
	//
	//  Um controle para inserir um mês e ano, sem fuso horário.
	KInputTypeMonth InputType = "month"

	// KInputTypeNumber
	//
	// English:
	//
	//  A control for entering a number. Displays a spinner and adds default validation when supported.
	//  Displays a numeric keypad in some devices with dynamic keypads.
	//
	// Português:
	//
	//  Um controle para inserir um número. Exibe um spinner e adiciona validação padrão quando
	//  suportado. Exibe um teclado numérico em alguns dispositivos com teclados dinâmicos.
	KInputTypeNumber InputType = "number"

	// KInputTypePassword
	//
	// English:
	//
	//  A single-line text field whose value is obscured. Will alert user if site is not secure.
	//
	// Português:
	//
	//  Um campo de texto de linha única cujo valor está obscurecido. Alertará o usuário se o site não
	//  for seguro.
	KInputTypePassword InputType = "password"

	// KInputTypeRadio
	//
	// English:
	//
	//  A radio button, allowing a single value to be selected out of multiple choices with the same
	//  name value.
	//
	// Português:
	//
	//  Um botão de opção, permitindo que um único valor seja selecionado entre várias opções com o
	//  mesmo valor de nome.
	KInputTypeRadio InputType = "radio"

	// KInputTypeRange
	//
	// English:
	//
	//  A control for entering a number whose exact value is not important. Displays as a range widget
	//  defaulting to the middle value. Used in conjunction min and max to define the range of
	//  acceptable values.
	//
	// Português:
	//
	//  Um controle para inserir um número cujo valor exato não é importante. Exibe como um widget de
	//  intervalo padronizado para o valor médio. Usado em conjunto min e max para definir a faixa de
	//  valores aceitáveis.
	KInputTypeRange InputType = "range"

	// KInputTypeSearch
	//
	// English:
	//
	//  A single-line text field for entering search strings. Line-breaks are automatically removed
	//  from the input value. May include a delete icon in supporting browsers that can be used to
	//  clear the field. Displays a search icon instead of enter key on some devices with dynamic
	//  keypads.
	//
	// Português:
	//
	//  Um campo de texto de linha única para inserir strings de pesquisa. As quebras de linha são
	//  removidas automaticamente do valor de entrada. Pode incluir um ícone de exclusão em navegadores
	//  de suporte que podem ser usados para limpar o campo. Exibe um ícone de pesquisa em vez da tecla
	//  Enter em alguns dispositivos com teclados dinâmicos.
	KInputTypeSearch InputType = "search"

	// KInputTypeSubmit
	//
	// English:
	//
	//  A button that submits the form.
	//
	// Português:
	//
	//  Um botão que envia o formulário.
	KInputTypeSubmit InputType = "submit"

	// KInputTypeTel
	//
	// English:
	//
	//  A control for entering a telephone number. Displays a telephone keypad in some devices with
	//  dynamic keypads.
	//
	// Português:
	//
	//  Um controle para inserir um número de telefone. Exibe um teclado de telefone em alguns
	//  dispositivos com teclados dinâmicos.
	KInputTypeTel InputType = "tel"

	// KInputTypeText
	//
	// English:
	//
	//  A single-line text field. Line-breaks are automatically removed from the input value. (Default)
	//
	// Português:
	//
	//  Mampo de texto de linha única. As quebras de linha são removidas automaticamente do valor de
	//  entrada. (Padrão)
	KInputTypeText InputType = "text"

	// KInputTypeTime
	//
	// English:
	//
	//  A control for entering a time value with no time zone.
	//
	// Português:
	//
	//  Um controle para inserir um valor de tempo sem fuso horário.
	KInputTypeTime InputType = "time"

	// KInputTypeUrl
	//
	// English:
	//
	//  A field for entering a URL. Looks like a text input, but has validation parameters and relevant
	//  keyboard in supporting browsers and devices with dynamic keyboards.
	//
	// Português:
	//
	//  Um campo para inserir um URL. Parece uma entrada de texto, mas possui parâmetros de validação
	//  e teclado relevante no suporte a navegadores e dispositivos com teclados dinâmicos.
	KInputTypeUrl InputType = "url"

	// KInputTypeWeek
	//
	// English:
	//
	//  A control for entering a date consisting of a week-year number and a week number with no time
	//  zone.
	//
	// Português:
	//
	//  Um controle para inserir uma data que consiste em um número de ano-semana e um número de semana
	//  sem fuso horário.
	KInputTypeWeek InputType = "week"
)

func (InputType) String 

func (e InputType) String() string

type JoinRule 

type JoinRule string
const (
	// KJoinRuleBevel
	//
	// English:
	//
	//  Creates a beveled corner.
	//
	// Português:
	//
	//  Creates a beveled corner.
	KJoinRuleBevel JoinRule = "bevel"

	// KJoinRuleRound
	//
	// English:
	//
	//  A Creates a rounded corner.
	//
	// Português:
	//
	//  A Cria um canto arredondado.
	KJoinRuleRound JoinRule = "round"

	// KJoinRuleMiter
	//
	// English:
	//
	//  (Default) Creates a sharp corner.
	//
	// Português:
	//
	//  (Default) Cria um canto afiado.
	KJoinRuleMiter JoinRule = "miter"
)

func (JoinRule) String 

func (e JoinRule) String() string

type KeyTimes 

type KeyTimes struct {
	// contains filtered or unexported fields
}

func (*KeyTimes) Add 

func (e *KeyTimes) Add(k float64)

func (KeyTimes) String 

func (e KeyTimes) String() string

type Language 

type Language string
const (
	// KLanguageAbkhazian
	//
	// English:
	//
	//  Abkhazian: 'ab'
	KLanguageAbkhazian Language = "ab"

	// KLanguageAfar
	//
	// English:
	//
	//  Afar: 'aa'
	KLanguageAfar Language = "aa"

	// KLanguageAfrikaans
	//
	// English:
	//
	//  Afrikaans: 'af'
	KLanguageAfrikaans Language = "af"

	// KLanguageAkan
	//
	// English:
	//
	//  Akan: 'ak'
	KLanguageAkan Language = "ak"

	// KLanguageAlbanian
	//
	// English:
	//
	//  Albanian: 'sq'
	KLanguageAlbanian Language = "sq"

	// KLanguageAmharic
	//
	// English:
	//
	//  Amharic: 'am'
	KLanguageAmharic Language = "am"

	// KLanguageArabic
	//
	// English:
	//
	//  Arabic: 'ar'
	KLanguageArabic Language = "ar"

	// KLanguageAragonese
	//
	// English:
	//
	//  Aragonese: 'an'
	KLanguageAragonese Language = "an"

	// KLanguageArmenian
	//
	// English:
	//
	//  Armenian: 'hy'
	KLanguageArmenian Language = "hy"

	// KLanguageAssamese
	//
	// English:
	//
	//  Assamese: 'as'
	KLanguageAssamese Language = "as"

	// KLanguageAvaric
	//
	// English:
	//
	//  Avaric: 'av'
	KLanguageAvaric Language = "av"

	// KLanguageAvestan
	//
	// English:
	//
	//  Avestan: 'ae'
	KLanguageAvestan Language = "ae"

	// KLanguageAymara
	//
	// English:
	//
	//  Aymara: 'ay'
	KLanguageAymara Language = "ay"

	// KLanguageAzerbaijani
	//
	// English:
	//
	//  Azerbaijani: 'az'
	KLanguageAzerbaijani Language = "az"

	// KLanguageBambara
	//
	// English:
	//
	//  Bambara: 'bm'
	KLanguageBambara Language = "bm"

	// KLanguageBashkir
	//
	// English:
	//
	//  Bashkir: 'ba'
	KLanguageBashkir Language = "ba"

	// KLanguageBasque
	//
	// English:
	//
	//  Basque: 'eu'
	KLanguageBasque Language = "eu"

	// KLanguageBelarusian
	//
	// English:
	//
	//  Belarusian: 'be'
	KLanguageBelarusian Language = "be"

	// KLanguageBengaliBangla
	//
	// English:
	//
	//  Bengali (Bangla): 'bn'
	KLanguageBengaliBangla Language = "bn"

	// KLanguageBihari
	//
	// English:
	//
	//  Bihari: 'bh'
	KLanguageBihari Language = "bh"

	// KLanguageBislama
	//
	// English:
	//
	//  Bislama: 'bi'
	KLanguageBislama Language = "bi"

	// KLanguageBosnian
	//
	// English:
	//
	//  Bosnian: 'bs'
	KLanguageBosnian Language = "bs"

	// KLanguageBreton
	//
	// English:
	//
	//  Breton: 'br'
	KLanguageBreton Language = "br"

	// KLanguageBulgarian
	//
	// English:
	//
	//  Bulgarian: 'bg'
	KLanguageBulgarian Language = "bg"

	// KLanguageBurmese
	//
	// English:
	//
	//  Burmese: 'my'
	KLanguageBurmese Language = "my"

	// KLanguageCatalan
	//
	// English:
	//
	//  Catalan: 'ca'
	KLanguageCatalan Language = "ca"

	// KLanguageChamorro
	//
	// English:
	//
	//  Chamorro: 'ch'
	KLanguageChamorro Language = "ch"

	// KLanguageChechen
	//
	// English:
	//
	//  Chechen: 'ce'
	KLanguageChechen Language = "ce"

	// KLanguageChichewa
	//
	// English:
	//
	//  Chichewa: 'ny'
	KLanguageChichewa Language = "ny"

	// KLanguageChewa
	//
	// English:
	//
	//  Chewa: 'ny'
	KLanguageChewa Language = "ny"

	// KLanguageNyanja
	//
	// English:
	//
	//  Nyanja: 'ny'
	KLanguageNyanja Language = "ny"

	// KLanguageChinese
	//
	// English:
	//
	//  Chinese: 'zh'
	KLanguageChinese Language = "zh"

	// KLanguageChineseSimplified
	//
	// English:
	//
	//  Chinese (Simplified): 'zh-Hans'
	KLanguageChineseSimplified Language = "zh-Hans"

	// KLanguageChineseTraditional
	//
	// English:
	//
	//  Chinese (Traditional): 'zh-Hant'
	KLanguageChineseTraditional Language = "zh-Hant"

	// KLanguageChuvash
	//
	// English:
	//
	//  Chuvash: 'cv'
	KLanguageChuvash Language = "cv"

	// KLanguageCornish
	//
	// English:
	//
	//  Cornish: 'kw'
	KLanguageCornish Language = "kw"

	// KLanguageCorsican
	//
	// English:
	//
	//  Corsican: 'co'
	KLanguageCorsican Language = "co"

	// KLanguageCree
	//
	// English:
	//
	//  Cree: 'cr'
	KLanguageCree Language = "cr"

	// KLanguageCroatian
	//
	// English:
	//
	//  Croatian: 'hr'
	KLanguageCroatian Language = "hr"

	// KLanguageCzech
	//
	// English:
	//
	//  Czech: 'cs'
	KLanguageCzech Language = "cs"

	// KLanguageDanish
	//
	// English:
	//
	//  Danish: 'da'
	KLanguageDanish Language = "da"

	// KLanguageDivehi
	//
	// English:
	//
	//  Divehi: 'dv'
	KLanguageDivehi Language = "dv"

	// KLanguageDhivehi
	//
	// English:
	//
	//  Dhivehi: 'dv'
	KLanguageDhivehi Language = "dv"

	// KLanguageMaldivian
	//
	// English:
	//
	//  Maldivian: 'dv'
	KLanguageMaldivian Language = "dv"

	// KLanguageDutch
	//
	// English:
	//
	//  Dutch: 'nl'
	KLanguageDutch Language = "nl"

	// KLanguageDzongkha
	//
	// English:
	//
	//  Dzongkha: 'dz'
	KLanguageDzongkha Language = "dz"

	// KLanguageEnglish
	//
	// English:
	//
	//  English: 'en'
	KLanguageEnglish Language = "en"

	// KLanguageEsperanto
	//
	// English:
	//
	//  Esperanto: 'eo'
	KLanguageEsperanto Language = "eo"

	// KLanguageEstonian
	//
	// English:
	//
	//  Estonian: 'et'
	KLanguageEstonian Language = "et"

	// KLanguageEwe
	//
	// English:
	//
	//  Ewe: 'ee'
	KLanguageEwe Language = "ee"

	// KLanguageFaroese
	//
	// English:
	//
	//  Faroese: 'fo'
	KLanguageFaroese Language = "fo"

	// KLanguageFijian
	//
	// English:
	//
	//  Fijian: 'fj'
	KLanguageFijian Language = "fj"

	// KLanguageFinnish
	//
	// English:
	//
	//  Finnish: 'fi'
	KLanguageFinnish Language = "fi"

	// KLanguageFrench
	//
	// English:
	//
	//  French: 'fr'
	KLanguageFrench Language = "fr"

	// KLanguageFula
	//
	// English:
	//
	//  Fula: 'ff'
	KLanguageFula Language = "ff"

	// KLanguageFulah
	//
	// English:
	//
	//  Fulah: 'ff'
	KLanguageFulah Language = "ff"

	// KLanguagePulaar
	//
	// English:
	//
	//  Pulaar: 'ff'
	KLanguagePulaar Language = "ff"

	// KLanguagePular
	//
	// English:
	//
	//  Pular: 'ff'
	KLanguagePular Language = "ff"

	// KLanguageGalician
	//
	// English:
	//
	//  Galician: 'gl'
	KLanguageGalician Language = "gl"

	// KLanguageGaelicScottish
	//
	// English:
	//
	//  Gaelic (Scottish): 'gd'
	KLanguageGaelicScottish Language = "gd"

	// KLanguageGaelicManx
	//
	// English:
	//
	//  Gaelic (Manx): 'gv'
	KLanguageGaelicManx Language = "gv"

	// KLanguageGeorgian
	//
	// English:
	//
	//  Georgian: 'ka'
	KLanguageGeorgian Language = "ka"

	// KLanguageGerman
	//
	// English:
	//
	//  German: 'de'
	KLanguageGerman Language = "de"

	// KLanguageGreek
	//
	// English:
	//
	//  Greek: 'el'
	KLanguageGreek Language = "el"

	// KLanguageGuarani
	//
	// English:
	//
	//  Guarani: 'gn'
	KLanguageGuarani Language = "gn"

	// KLanguageGujarati
	//
	// English:
	//
	//  Gujarati: 'gu'
	KLanguageGujarati Language = "gu"

	// KLanguageHaitianCreole
	//
	// English:
	//
	//  Haitian Creole: 'ht'
	KLanguageHaitianCreole Language = "ht"

	// KLanguageHausa
	//
	// English:
	//
	//  Hausa: 'ha'
	KLanguageHausa Language = "ha"

	// KLanguageHebrew
	//
	// English:
	//
	//  Hebrew: 'he'
	KLanguageHebrew Language = "he"

	// KLanguageHerero
	//
	// English:
	//
	//  Herero: 'hz'
	KLanguageHerero Language = "hz"

	// KLanguageHindi
	//
	// English:
	//
	//  Hindi: 'hi'
	KLanguageHindi Language = "hi"

	// KLanguageHiriMotu
	//
	// English:
	//
	//  Hiri Motu: 'ho'
	KLanguageHiriMotu Language = "ho"

	// KLanguageHungarian
	//
	// English:
	//
	//  Hungarian: 'hu'
	KLanguageHungarian Language = "hu"

	// KLanguageIcelandic
	//
	// English:
	//
	//  Icelandic: 'is'
	KLanguageIcelandic Language = "is"

	// KLanguageIdo
	//
	// English:
	//
	//  Ido: 'io'
	KLanguageIdo Language = "io"

	// KLanguageIgbo
	//
	// English:
	//
	//  Igbo: 'ig'
	KLanguageIgbo Language = "ig"

	// KLanguageIndonesian
	//
	// English:
	//
	//  Indonesian: 'id, in'
	KLanguageIndonesian Language = "id, in"

	// KLanguageInterlingua
	//
	// English:
	//
	//  Interlingua: 'ia'
	KLanguageInterlingua Language = "ia"

	// KLanguageInterlingue
	//
	// English:
	//
	//  Interlingue: 'ie'
	KLanguageInterlingue Language = "ie"

	// KLanguageInuktitut
	//
	// English:
	//
	//  Inuktitut: 'iu'
	KLanguageInuktitut Language = "iu"

	// KLanguageInupiak
	//
	// English:
	//
	//  Inupiak: 'ik'
	KLanguageInupiak Language = "ik"

	// KLanguageIrish
	//
	// English:
	//
	//  Irish: 'ga'
	KLanguageIrish Language = "ga"

	// KLanguageItalian
	//
	// English:
	//
	//  Italian: 'it'
	KLanguageItalian Language = "it"

	// KLanguageJapanese
	//
	// English:
	//
	//  Japanese: 'ja'
	KLanguageJapanese Language = "ja"

	// KLanguageJavanese
	//
	// English:
	//
	//  Javanese: 'jv'
	KLanguageJavanese Language = "jv"

	// KLanguageKalaallisut
	//
	// English:
	//
	//  Kalaallisut: 'kl'
	KLanguageKalaallisut Language = "kl"

	// KLanguageGreenlandic
	//
	// English:
	//
	//  Greenlandic: 'kl'
	KLanguageGreenlandic Language = "kl"

	// KLanguageKannada
	//
	// English:
	//
	//  Kannada: 'kn'
	KLanguageKannada Language = "kn"

	// KLanguageKanuri
	//
	// English:
	//
	//  Kanuri: 'kr'
	KLanguageKanuri Language = "kr"

	// KLanguageKashmiri
	//
	// English:
	//
	//  Kashmiri: 'ks'
	KLanguageKashmiri Language = "ks"

	// KLanguageKazakh
	//
	// English:
	//
	//  Kazakh: 'kk'
	KLanguageKazakh Language = "kk"

	// KLanguageKhmer
	//
	// English:
	//
	//  Khmer: 'km'
	KLanguageKhmer Language = "km"

	// KLanguageKikuyu
	//
	// English:
	//
	//  Kikuyu: 'ki'
	KLanguageKikuyu Language = "ki"

	// KLanguageKinyarwandaRwanda
	//
	// English:
	//
	//  Kinyarwanda (Rwanda): 'rw'
	KLanguageKinyarwandaRwanda Language = "rw"

	// KLanguageKirundi
	//
	// English:
	//
	//  Kirundi: 'rn'
	KLanguageKirundi Language = "rn"

	// KLanguageKyrgyz
	//
	// English:
	//
	//  Kyrgyz: 'ky'
	KLanguageKyrgyz Language = "ky"

	// KLanguageKomi
	//
	// English:
	//
	//  Komi: 'kv'
	KLanguageKomi Language = "kv"

	// KLanguageKongo
	//
	// English:
	//
	//  Kongo: 'kg'
	KLanguageKongo Language = "kg"

	// KLanguageKorean
	//
	// English:
	//
	//  Korean: 'ko'
	KLanguageKorean Language = "ko"

	// KLanguageKurdish
	//
	// English:
	//
	//  Kurdish: 'ku'
	KLanguageKurdish Language = "ku"

	// KLanguageKwanyama
	//
	// English:
	//
	//  Kwanyama: 'kj'
	KLanguageKwanyama Language = "kj"

	// KLanguageLao
	//
	// English:
	//
	//  Lao: 'lo'
	KLanguageLao Language = "lo"

	// KLanguageLatin
	//
	// English:
	//
	//  Latin: 'la'
	KLanguageLatin Language = "la"

	// KLanguageLatvianLettish
	//
	// English:
	//
	//  Latvian (Lettish): 'lv'
	KLanguageLatvianLettish Language = "lv"

	// KLanguageLimburgishLimburger
	//
	// English:
	//
	//  Limburgish ( Limburger): 'li'
	KLanguageLimburgishLimburger Language = "li"

	// KLanguageLingala
	//
	// English:
	//
	//  Lingala: 'ln'
	KLanguageLingala Language = "ln"

	// KLanguageLithuanian
	//
	// English:
	//
	//  Lithuanian: 'lt'
	KLanguageLithuanian Language = "lt"

	// KLanguageLugaKatanga
	//
	// English:
	//
	//  Luga-Katanga: 'lu'
	KLanguageLugaKatanga Language = "lu"

	// KLanguageLuganda
	//
	// English:
	//
	//  Luganda: 'lg'
	KLanguageLuganda Language = "lg"

	// KLanguageGanda
	//
	// English:
	//
	//  Ganda: 'lg'
	KLanguageGanda Language = "lg"

	// KLanguageLuxembourgish
	//
	// English:
	//
	//  Luxembourgish: 'lb'
	KLanguageLuxembourgish Language = "lb"

	// KLanguageManx
	//
	// English:
	//
	//  Manx: 'gv'
	KLanguageManx Language = "gv"

	// KLanguageMacedonian
	//
	// English:
	//
	//  Macedonian: 'mk'
	KLanguageMacedonian Language = "mk"

	// KLanguageMalagasy
	//
	// English:
	//
	//  Malagasy: 'mg'
	KLanguageMalagasy Language = "mg"

	// KLanguageMalay
	//
	// English:
	//
	//  Malay: 'ms'
	KLanguageMalay Language = "ms"

	// KLanguageMalayalam
	//
	// English:
	//
	//  Malayalam: 'ml'
	KLanguageMalayalam Language = "ml"

	// KLanguageMaltese
	//
	// English:
	//
	//  Maltese: 'mt'
	KLanguageMaltese Language = "mt"

	// KLanguageMaori
	//
	// English:
	//
	//  Maori: 'mi'
	KLanguageMaori Language = "mi"

	// KLanguageMarathi
	//
	// English:
	//
	//  Marathi: 'mr'
	KLanguageMarathi Language = "mr"

	// KLanguageMarshallese
	//
	// English:
	//
	//  Marshallese: 'mh'
	KLanguageMarshallese Language = "mh"

	// KLanguageMoldavian
	//
	// English:
	//
	//  Moldavian: 'mo'
	KLanguageMoldavian Language = "mo"

	// KLanguageMongolian
	//
	// English:
	//
	//  Mongolian: 'mn'
	KLanguageMongolian Language = "mn"

	// KLanguageNauru
	//
	// English:
	//
	//  Nauru: 'na'
	KLanguageNauru Language = "na"

	// KLanguageNavajo
	//
	// English:
	//
	//  Navajo: 'nv'
	KLanguageNavajo Language = "nv"

	// KLanguageNdonga
	//
	// English:
	//
	//  Ndonga: 'ng'
	KLanguageNdonga Language = "ng"

	// KLanguageNorthernNdebele
	//
	// English:
	//
	//  Northern Ndebele: 'nd'
	KLanguageNorthernNdebele Language = "nd"

	// KLanguageNepali
	//
	// English:
	//
	//  Nepali: 'ne'
	KLanguageNepali Language = "ne"

	// KLanguageNorwegian
	//
	// English:
	//
	//  Norwegian: 'no'
	KLanguageNorwegian Language = "no"

	// KLanguageNorwegianBokmål
	//
	// English:
	//
	//  Norwegian bokmål: 'nb'
	KLanguageNorwegianBokmål Language = "nb"

	// KLanguageNorwegianNynorsk
	//
	// English:
	//
	//  Norwegian nynorsk: 'nn'
	KLanguageNorwegianNynorsk Language = "nn"

	// KLanguageNuosu
	//
	// English:
	//
	//  Nuosu: 'ii'
	KLanguageNuosu Language = "ii"

	// KLanguageOccitan
	//
	// English:
	//
	//  Occitan: 'oc'
	KLanguageOccitan Language = "oc"

	// KLanguageOjibwe
	//
	// English:
	//
	//  Ojibwe: 'oj'
	KLanguageOjibwe Language = "oj"

	// KLanguageOldChurchSlavonic
	//
	// English:
	//
	//  Old Church Slavonic: 'cu'
	KLanguageOldChurchSlavonic Language = "cu"

	// KLanguageOldBulgarian
	//
	// English:
	//
	//  Old Bulgarian: 'cu'
	KLanguageOldBulgarian Language = "cu"

	// KLanguageOriya
	//
	// English:
	//
	//  Oriya: 'or'
	KLanguageOriya Language = "or"

	// KLanguageOromoAfaanOromo
	//
	// English:
	//
	//  Oromo (Afaan Oromo): 'om'
	KLanguageOromoAfaanOromo Language = "om"

	// KLanguageOssetian
	//
	// English:
	//
	//  Ossetian: 'os'
	KLanguageOssetian Language = "os"

	// KLanguagePali
	//
	// English:
	//
	//  Pāli: 'pi'
	KLanguagePali Language = "pi"

	// KLanguagePashto
	//
	// English:
	//
	//  Pashto: 'ps'
	KLanguagePashto Language = "ps"

	// KLanguagePushto
	//
	// English:
	//
	//  Pushto: 'ps'
	KLanguagePushto Language = "ps"

	// KLanguagePersianFarsi
	//
	// English:
	//
	//  Persian (Farsi): 'fa'
	KLanguagePersianFarsi Language = "fa"

	// KLanguagePolish
	//
	// English:
	//
	//  Polish: 'pl'
	KLanguagePolish Language = "pl"

	// KLanguagePortuguese
	//
	// English:
	//
	//  Portuguese: 'pt'
	KLanguagePortuguese Language = "pt"

	// KLanguagePunjabiEastern
	//
	// English:
	//
	//  Punjabi (Eastern): 'pa'
	KLanguagePunjabiEastern Language = "pa"

	// KLanguageQuechua
	//
	// English:
	//
	//  Quechua: 'qu'
	KLanguageQuechua Language = "qu"

	// KLanguageRomansh
	//
	// English:
	//
	//  Romansh: 'rm'
	KLanguageRomansh Language = "rm"

	// KLanguageRomanian
	//
	// English:
	//
	//  Romanian: 'ro'
	KLanguageRomanian Language = "ro"

	// KLanguageRussian
	//
	// English:
	//
	//  Russian: 'ru'
	KLanguageRussian Language = "ru"

	// KLanguageSami
	//
	// English:
	//
	//  Sami: 'se'
	KLanguageSami Language = "se"

	// KLanguageSamoan
	//
	// English:
	//
	//  Samoan: 'sm'
	KLanguageSamoan Language = "sm"

	// KLanguageSango
	//
	// English:
	//
	//  Sango: 'sg'
	KLanguageSango Language = "sg"

	// KLanguageSanskrit
	//
	// English:
	//
	//  Sanskrit: 'sa'
	KLanguageSanskrit Language = "sa"

	// KLanguageSerbian
	//
	// English:
	//
	//  Serbian: 'sr'
	KLanguageSerbian Language = "sr"

	// KLanguageSerboCroatian
	//
	// English:
	//
	//  Serbo-Croatian: 'sh'
	KLanguageSerboCroatian Language = "sh"

	// KLanguageSesotho
	//
	// English:
	//
	//  Sesotho: 'st'
	KLanguageSesotho Language = "st"

	// KLanguageSetswana
	//
	// English:
	//
	//  Setswana: 'tn'
	KLanguageSetswana Language = "tn"

	// KLanguageShona
	//
	// English:
	//
	//  Shona: 'sn'
	KLanguageShona Language = "sn"

	// KLanguageSichuanYi
	//
	// English:
	//
	//  Sichuan Yi: 'ii'
	KLanguageSichuanYi Language = "ii"

	// KLanguageSindhi
	//
	// English:
	//
	//  Sindhi: 'sd'
	KLanguageSindhi Language = "sd"

	// KLanguageSinhalese
	//
	// English:
	//
	//  Sinhalese: 'si'
	KLanguageSinhalese Language = "si"

	// KLanguageSiswati
	//
	// English:
	//
	//  Siswati: 'ss'
	KLanguageSiswati Language = "ss"

	// KLanguageSlovak
	//
	// English:
	//
	//  Slovak: 'sk'
	KLanguageSlovak Language = "sk"

	// KLanguageSlovenian
	//
	// English:
	//
	//  Slovenian: 'sl'
	KLanguageSlovenian Language = "sl"

	// KLanguageSomali
	//
	// English:
	//
	//  Somali: 'so'
	KLanguageSomali Language = "so"

	// KLanguageSouthernNdebele
	//
	// English:
	//
	//  Southern Ndebele: 'nr'
	KLanguageSouthernNdebele Language = "nr"

	// KLanguageSpanish
	//
	// English:
	//
	//  Spanish: 'es'
	KLanguageSpanish Language = "es"

	// KLanguageSundanese
	//
	// English:
	//
	//  Sundanese: 'su'
	KLanguageSundanese Language = "su"

	// KLanguageSwahiliKiswahili
	//
	// English:
	//
	//  Swahili (Kiswahili): 'sw'
	KLanguageSwahiliKiswahili Language = "sw"

	// KLanguageSwati
	//
	// English:
	//
	//  Swati: 'ss'
	KLanguageSwati Language = "ss"

	// KLanguageSwedish
	//
	// English:
	//
	//  Swedish: 'sv'
	KLanguageSwedish Language = "sv"

	// KLanguageTagalog
	//
	// English:
	//
	//  Tagalog: 'tl'
	KLanguageTagalog Language = "tl"

	// KLanguageTahitian
	//
	// English:
	//
	//  Tahitian: 'ty'
	KLanguageTahitian Language = "ty"

	// KLanguageTajik
	//
	// English:
	//
	//  Tajik: 'tg'
	KLanguageTajik Language = "tg"

	// KLanguageTamil
	//
	// English:
	//
	//  Tamil: 'ta'
	KLanguageTamil Language = "ta"

	// KLanguageTatar
	//
	// English:
	//
	//  Tatar: 'tt'
	KLanguageTatar Language = "tt"

	// KLanguageTelugu
	//
	// English:
	//
	//  Telugu: 'te'
	KLanguageTelugu Language = "te"

	// KLanguageThai
	//
	// English:
	//
	//  Thai: 'th'
	KLanguageThai Language = "th"

	// KLanguageTibetan
	//
	// English:
	//
	//  Tibetan: 'bo'
	KLanguageTibetan Language = "bo"

	// KLanguageTigrinya
	//
	// English:
	//
	//  Tigrinya: 'ti'
	KLanguageTigrinya Language = "ti"

	// KLanguageTonga
	//
	// English:
	//
	//  Tonga: 'to'
	KLanguageTonga Language = "to"

	// KLanguageTsonga
	//
	// English:
	//
	//  Tsonga: 'ts'
	KLanguageTsonga Language = "ts"

	// KLanguageTurkish
	//
	// English:
	//
	//  Turkish: 'tr'
	KLanguageTurkish Language = "tr"

	// KLanguageTurkmen
	//
	// English:
	//
	//  Turkmen: 'tk'
	KLanguageTurkmen Language = "tk"

	// KLanguageTwi
	//
	// English:
	//
	//  Twi: 'tw'
	KLanguageTwi Language = "tw"

	// KLanguageUyghur
	//
	// English:
	//
	//  Uyghur: 'ug'
	KLanguageUyghur Language = "ug"

	// KLanguageUkrainian
	//
	// English:
	//
	//  Ukrainian: 'uk'
	KLanguageUkrainian Language = "uk"

	// KLanguageUrdu
	//
	// English:
	//
	//  Urdu: 'ur'
	KLanguageUrdu Language = "ur"

	// KLanguageUzbek
	//
	// English:
	//
	//  Uzbek: 'uz'
	KLanguageUzbek Language = "uz"

	// KLanguageVenda
	//
	// English:
	//
	//  Venda: 've'
	KLanguageVenda Language = "ve"

	// KLanguageVietnamese
	//
	// English:
	//
	//  Vietnamese: 'vi'
	KLanguageVietnamese Language = "vi"

	// KLanguageVolapük
	//
	// English:
	//
	//  Volapük: 'vo'
	KLanguageVolapük Language = "vo"

	// KLanguageWallon
	//
	// English:
	//
	//  Wallon: 'wa'
	KLanguageWallon Language = "wa"

	// KLanguageWelsh
	//
	// English:
	//
	//  Welsh: 'cy'
	KLanguageWelsh Language = "cy"

	// KLanguageWolof
	//
	// English:
	//
	//  Wolof: 'wo'
	KLanguageWolof Language = "wo"

	// KLanguageWesternFrisian
	//
	// English:
	//
	//  Western Frisian: 'fy'
	KLanguageWesternFrisian Language = "fy"

	// KLanguageXhosa
	//
	// English:
	//
	//  Xhosa: 'xh'
	KLanguageXhosa Language = "xh"

	// KLanguageYiddish
	//
	// English:
	//
	//  Yiddish: 'yi, ji'
	KLanguageYiddish Language = "yi, ji"

	// KLanguageYoruba
	//
	// English:
	//
	//  Yoruba: 'yo'
	KLanguageYoruba Language = "yo"

	// KLanguageZhuang
	//
	// English:
	//
	//  Zhuang: 'za'
	KLanguageZhuang Language = "za"

	// KLanguageChuang
	//
	// English:
	//
	//  Chuang: 'za'
	KLanguageChuang Language = "za"

	// KLanguageZulu
	//
	// English:
	//
	//  Zulu: 'zu'
	KLanguageZulu Language = "zu"
)

func (Language) String 

func (e Language) String() string

type MeetOrSliceReference 

type MeetOrSliceReference string
const (
	// KMeetOrSliceReferenceMeet
	//
	// English:
	//
	//  (default) Scale the graphic such that:
	//
	// Aspect ratio is preserved
	//
	// The entire viewBox is visible within the viewport
	//
	// The viewBox is scaled up as much as possible, while still meeting the other criteria
	//
	// In this case, if the aspect ratio of the graphic does not match the viewport, some of the viewport will extend
	// beyond the bounds of the viewBox (i.e., the area into which the viewBox will draw will be smaller than the
	// viewport).
	//
	// Português:
	//
	//  (default) Dimensione o gráfico de tal forma que:
	//
	// Proporção é preservada
	//
	// Toda a viewBox é visível dentro da viewport
	//
	// O viewBox é ampliado o máximo possível, enquanto ainda atende aos outros critérios
	//
	// Nesse caso, se a proporção do gráfico não corresponder à janela de visualização, parte da janela de visualização se
	// estenderá além dos limites da caixa de visualização (ou seja, a área na qual a caixa de visualização será desenhada
	// será menor que a porta de visualização).
	KMeetOrSliceReferenceMeet MeetOrSliceReference = "meet"

	// KMeetOrSliceReferenceSlice
	//
	// English:
	//
	//  Scale the graphic such that:
	//
	// Aspect ratio is preserved
	//
	// The entire viewport is covered by the viewBox
	//
	// The viewBox is scaled down as much as possible, while still meeting the other criteria
	//
	// In this case, if the aspect ratio of the viewBox does not match the viewport, some of the viewBox will extend
	// beyond the bounds of the viewport (i.e., the area into which the viewBox will draw is larger than the viewport).
	//
	// Português:
	//
	//  Dimensione o gráfico de tal forma que:
	//
	// Proporção é preservada
	//
	// A viewport inteira é coberta pela viewBox
	//
	// A viewBox é reduzida o máximo possível, enquanto ainda atende aos outros critérios
	//
	// Nesse caso, se a proporção da viewBox não corresponder à viewport, parte da viewBox se estenderá além dos limites
	// da viewport (ou seja, a área na qual a viewBox desenhará é maior que a viewport).
	KMeetOrSliceReferenceSlice MeetOrSliceReference = "slice"
)

func (MeetOrSliceReference) String 

func (e MeetOrSliceReference) String() string

type Mime 

type Mime string

Mime

Source: 

https://www.iana.org/assignments/media-types/media-types.xhtml#audio

English: 

A MIME type (now properly called "media type", but also sometimes "content type") is a string sent
along with a file indicating the type of the file (describing the content format, for example, a
sound file might be labeled audio/ogg, or an image file image/png).

It serves the same purpose as filename extensions traditionally do on Windows. The name originates from the MIME standard originally used in E-Mail.

Português: 

Um tipo MIME (agora chamado corretamente de "tipo de mídia", mas também às vezes "tipo de
conteúdo") é uma string enviada junto com um arquivo que indica o tipo do arquivo (descrevendo o
formato do conteúdo, por exemplo, um arquivo de som pode ser rotulado como audio/ogg , ou um
arquivo de imagem image/png).

Ele serve ao mesmo propósito que as extensões de nome de arquivo tradicionalmente fazem no Windows. O nome se origina do padrão MIME originalmente usado em E-Mail. 

const (
	// KMimeApplication1dInterleavedParityfec
	//
	// English:
	//
	//  Application type '1d-interleaved-parityfec'
	//
	// Português:
	//
	//  Aplicação tipo '1d-interleaved-parityfec'
	KMimeApplication1dInterleavedParityfec Mime = "application/1d-interleaved-parityfec"

	// KMimeApplication3gpdashQoeReportXml
	//
	// English:
	//
	//  Application type '3gpdash-qoe-report+xml'
	//
	// Português:
	//
	//  Aplicação tipo '3gpdash-qoe-report+xml'
	KMimeApplication3gpdashQoeReportXml Mime = "application/3gpdash-qoe-report+xml"

	// KMimeApplication3gppHalJson
	//
	// English:
	//
	//  Application type '3gppHal+json'
	//
	// Português:
	//
	//  Aplicação tipo '3gppHal+json'
	KMimeApplication3gppHalJson Mime = "application/3gppHal+json"

	// KMimeApplication3gppHalFormsJson
	//
	// English:
	//
	//  Application type '3gppHalForms+json'
	//
	// Português:
	//
	//  Aplicação tipo '3gppHalForms+json'
	KMimeApplication3gppHalFormsJson Mime = "application/3gppHalForms+json"

	// KMimeApplication3gppImsXml
	//
	// English:
	//
	//  Application type '3gpp-ims+xml'
	//
	// Português:
	//
	//  Aplicação tipo '3gpp-ims+xml'
	KMimeApplication3gppImsXml Mime = "application/3gpp-ims+xml"

	// KMimeApplicationA2L
	//
	// English:
	//
	//  Application type 'A2L'
	//
	// Português:
	//
	//  Aplicação tipo 'A2L'
	KMimeApplicationA2L Mime = "application/A2L"

	// KMimeApplicationAceCbor
	//
	// English:
	//
	//  Application type 'ace+cbor'
	//
	// Português:
	//
	//  Aplicação tipo 'ace+cbor'
	KMimeApplicationAceCbor Mime = "application/ace+cbor"

	// KMimeApplicationAceJson
	//
	// English:
	//
	//  Application type 'ace+json'
	//
	// Português:
	//
	//  Aplicação tipo 'ace+json'
	KMimeApplicationAceJson Mime = "application/ace+json"

	// KMimeApplicationActivemessage
	//
	// English:
	//
	//  Application type 'activemessage'
	//
	// Português:
	//
	//  Aplicação tipo 'activemessage'
	KMimeApplicationActivemessage Mime = "application/activemessage"

	// KMimeApplicationActivityJson
	//
	// English:
	//
	//  Application type 'activity+json'
	//
	// Português:
	//
	//  Aplicação tipo 'activity+json'
	KMimeApplicationActivityJson Mime = "application/activity+json"

	// KMimeApplicationAifCbor
	//
	// English:
	//
	//  Application type 'aif+cbor'
	//
	// Português:
	//
	//  Aplicação tipo 'aif+cbor'
	KMimeApplicationAifCbor Mime = "application/aif+cbor"

	// KMimeApplicationAifJson
	//
	// English:
	//
	//  Application type 'aif+json'
	//
	// Português:
	//
	//  Aplicação tipo 'aif+json'
	KMimeApplicationAifJson Mime = "application/aif+json"

	// KMimeApplicationAltoCdniJson
	//
	// English:
	//
	//  Application type 'alto-cdni+json'
	//
	// Português:
	//
	//  Aplicação tipo 'alto-cdni+json'
	KMimeApplicationAltoCdniJson Mime = "application/alto-cdni+json"

	// KMimeApplicationAltoCdnifilterJson
	//
	// English:
	//
	//  Application type 'alto-cdnifilter+json'
	//
	// Português:
	//
	//  Aplicação tipo 'alto-cdnifilter+json'
	KMimeApplicationAltoCdnifilterJson Mime = "application/alto-cdnifilter+json"

	// KMimeApplicationAltoCostmapJson
	//
	// English:
	//
	//  Application type 'alto-costmap+json'
	//
	// Português:
	//
	//  Aplicação tipo 'alto-costmap+json'
	KMimeApplicationAltoCostmapJson Mime = "application/alto-costmap+json"

	// KMimeApplicationAltoCostmapfilterJson
	//
	// English:
	//
	//  Application type 'alto-costmapfilter+json'
	//
	// Português:
	//
	//  Aplicação tipo 'alto-costmapfilter+json'
	KMimeApplicationAltoCostmapfilterJson Mime = "application/alto-costmapfilter+json"

	// KMimeApplicationAltoDirectoryJson
	//
	// English:
	//
	//  Application type 'alto-directory+json'
	//
	// Português:
	//
	//  Aplicação tipo 'alto-directory+json'
	KMimeApplicationAltoDirectoryJson Mime = "application/alto-directory+json"

	// KMimeApplicationAltoEndpointpropJson
	//
	// English:
	//
	//  Application type 'alto-endpointprop+json'
	//
	// Português:
	//
	//  Aplicação tipo 'alto-endpointprop+json'
	KMimeApplicationAltoEndpointpropJson Mime = "application/alto-endpointprop+json"

	// KMimeApplicationAltoEndpointpropparamsJson
	//
	// English:
	//
	//  Application type 'alto-endpointpropparams+json'
	//
	// Português:
	//
	//  Aplicação tipo 'alto-endpointpropparams+json'
	KMimeApplicationAltoEndpointpropparamsJson Mime = "application/alto-endpointpropparams+json"

	// KMimeApplicationAltoEndpointcostJson
	//
	// English:
	//
	//  Application type 'alto-endpointcost+json'
	//
	// Português:
	//
	//  Aplicação tipo 'alto-endpointcost+json'
	KMimeApplicationAltoEndpointcostJson Mime = "application/alto-endpointcost+json"

	// KMimeApplicationAltoEndpointcostparamsJson
	//
	// English:
	//
	//  Application type 'alto-endpointcostparams+json'
	//
	// Português:
	//
	//  Aplicação tipo 'alto-endpointcostparams+json'
	KMimeApplicationAltoEndpointcostparamsJson Mime = "application/alto-endpointcostparams+json"

	// KMimeApplicationAltoErrorJson
	//
	// English:
	//
	//  Application type 'alto-error+json'
	//
	// Português:
	//
	//  Aplicação tipo 'alto-error+json'
	KMimeApplicationAltoErrorJson Mime = "application/alto-error+json"

	// KMimeApplicationAltoNetworkmapfilterJson
	//
	// English:
	//
	//  Application type 'alto-networkmapfilter+json'
	//
	// Português:
	//
	//  Aplicação tipo 'alto-networkmapfilter+json'
	KMimeApplicationAltoNetworkmapfilterJson Mime = "application/alto-networkmapfilter+json"

	// KMimeApplicationAltoNetworkmapJson
	//
	// English:
	//
	//  Application type 'alto-networkmap+json'
	//
	// Português:
	//
	//  Aplicação tipo 'alto-networkmap+json'
	KMimeApplicationAltoNetworkmapJson Mime = "application/alto-networkmap+json"

	// KMimeApplicationAltoPropmapJson
	//
	// English:
	//
	//  Application type 'alto-propmap+json'
	//
	// Português:
	//
	//  Aplicação tipo 'alto-propmap+json'
	KMimeApplicationAltoPropmapJson Mime = "application/alto-propmap+json"

	// KMimeApplicationAltoPropmapparamsJson
	//
	// English:
	//
	//  Application type 'alto-propmapparams+json'
	//
	// Português:
	//
	//  Aplicação tipo 'alto-propmapparams+json'
	KMimeApplicationAltoPropmapparamsJson Mime = "application/alto-propmapparams+json"

	// KMimeApplicationAltoUpdatestreamcontrolJson
	//
	// English:
	//
	//  Application type 'alto-updatestreamcontrol+json'
	//
	// Português:
	//
	//  Aplicação tipo 'alto-updatestreamcontrol+json'
	KMimeApplicationAltoUpdatestreamcontrolJson Mime = "application/alto-updatestreamcontrol+json"

	// KMimeApplicationAltoUpdatestreamparamsJson
	//
	// English:
	//
	//  Application type 'alto-updatestreamparams+json'
	//
	// Português:
	//
	//  Aplicação tipo 'alto-updatestreamparams+json'
	KMimeApplicationAltoUpdatestreamparamsJson Mime = "application/alto-updatestreamparams+json"

	// KMimeApplicationAML
	//
	// English:
	//
	//  Application type 'AML'
	//
	// Português:
	//
	//  Aplicação tipo 'AML'
	KMimeApplicationAML Mime = "application/AML"

	// KMimeApplicationAndrewInset
	//
	// English:
	//
	//  Application type 'andrew-inset'
	//
	// Português:
	//
	//  Aplicação tipo 'andrew-inset'
	KMimeApplicationAndrewInset Mime = "application/andrew-inset"

	// KMimeApplicationApplefile
	//
	// English:
	//
	//  Application type 'applefile'
	//
	// Português:
	//
	//  Aplicação tipo 'applefile'
	KMimeApplicationApplefile Mime = "application/applefile"

	// KMimeApplicationAtJwt
	//
	// English:
	//
	//  Application type 'at+jwt'
	//
	// Português:
	//
	//  Aplicação tipo 'at+jwt'
	KMimeApplicationAtJwt Mime = "application/at+jwt"

	// KMimeApplicationATF
	//
	// English:
	//
	//  Application type 'ATF'
	//
	// Português:
	//
	//  Aplicação tipo 'ATF'
	KMimeApplicationATF Mime = "application/ATF"

	// KMimeApplicationATFX
	//
	// English:
	//
	//  Application type 'ATFX'
	//
	// Português:
	//
	//  Aplicação tipo 'ATFX'
	KMimeApplicationATFX Mime = "application/ATFX"

	// KMimeApplicationAtomXml
	//
	// English:
	//
	//  Application type 'atom+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'atom+xml'
	KMimeApplicationAtomXml Mime = "application/atom+xml"

	// KMimeApplicationAtomcatXml
	//
	// English:
	//
	//  Application type 'atomcat+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'atomcat+xml'
	KMimeApplicationAtomcatXml Mime = "application/atomcat+xml"

	// KMimeApplicationAtomdeletedXml
	//
	// English:
	//
	//  Application type 'atomdeleted+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'atomdeleted+xml'
	KMimeApplicationAtomdeletedXml Mime = "application/atomdeleted+xml"

	// KMimeApplicationAtomicmail
	//
	// English:
	//
	//  Application type 'atomicmail'
	//
	// Português:
	//
	//  Aplicação tipo 'atomicmail'
	KMimeApplicationAtomicmail Mime = "application/atomicmail"

	// KMimeApplicationAtomsvcXml
	//
	// English:
	//
	//  Application type 'atomsvc+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'atomsvc+xml'
	KMimeApplicationAtomsvcXml Mime = "application/atomsvc+xml"

	// KMimeApplicationAtscDwdXml
	//
	// English:
	//
	//  Application type 'atsc-dwd+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'atsc-dwd+xml'
	KMimeApplicationAtscDwdXml Mime = "application/atsc-dwd+xml"

	// KMimeApplicationAtscDynamicEventMessage
	//
	// English:
	//
	//  Application type 'atsc-dynamic-event-message'
	//
	// Português:
	//
	//  Aplicação tipo 'atsc-dynamic-event-message'
	KMimeApplicationAtscDynamicEventMessage Mime = "application/atsc-dynamic-event-message"

	// KMimeApplicationAtscHeldXml
	//
	// English:
	//
	//  Application type 'atsc-held+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'atsc-held+xml'
	KMimeApplicationAtscHeldXml Mime = "application/atsc-held+xml"

	// KMimeApplicationAtscRdtJson
	//
	// English:
	//
	//  Application type 'atsc-rdt+json'
	//
	// Português:
	//
	//  Aplicação tipo 'atsc-rdt+json'
	KMimeApplicationAtscRdtJson Mime = "application/atsc-rdt+json"

	// KMimeApplicationAtscRsatXml
	//
	// English:
	//
	//  Application type 'atsc-rsat+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'atsc-rsat+xml'
	KMimeApplicationAtscRsatXml Mime = "application/atsc-rsat+xml"

	// KMimeApplicationATXML
	//
	// English:
	//
	//  Application type 'ATXML'
	//
	// Português:
	//
	//  Aplicação tipo 'ATXML'
	KMimeApplicationATXML Mime = "application/ATXML"

	// KMimeApplicationAuthPolicyXml
	//
	// English:
	//
	//  Application type 'auth-policy+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'auth-policy+xml'
	KMimeApplicationAuthPolicyXml Mime = "application/auth-policy+xml"

	// KMimeApplicationBacnetXddZip
	//
	// English:
	//
	//  Application type 'bacnet-xdd+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'bacnet-xdd+zip'
	KMimeApplicationBacnetXddZip Mime = "application/bacnet-xdd+zip"

	// KMimeApplicationBatchSMTP
	//
	// English:
	//
	//  Application type 'batch-SMTP'
	//
	// Português:
	//
	//  Aplicação tipo 'batch-SMTP'
	KMimeApplicationBatchSMTP Mime = "application/batch-SMTP"

	// KMimeApplicationBeepXml
	//
	// English:
	//
	//  Application type 'beep+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'beep+xml'
	KMimeApplicationBeepXml Mime = "application/beep+xml"

	// KMimeApplicationCalendarJson
	//
	// English:
	//
	//  Application type 'calendar+json'
	//
	// Português:
	//
	//  Aplicação tipo 'calendar+json'
	KMimeApplicationCalendarJson Mime = "application/calendar+json"

	// KMimeApplicationCalendarXml
	//
	// English:
	//
	//  Application type 'calendar+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'calendar+xml'
	KMimeApplicationCalendarXml Mime = "application/calendar+xml"

	// KMimeApplicationCallCompletion
	//
	// English:
	//
	//  Application type 'call-completion'
	//
	// Português:
	//
	//  Aplicação tipo 'call-completion'
	KMimeApplicationCallCompletion Mime = "application/call-completion"

	// KMimeApplicationCALS1840
	//
	// English:
	//
	//  Application type 'CALS-1840'
	//
	// Português:
	//
	//  Aplicação tipo 'CALS-1840'
	KMimeApplicationCALS1840 Mime = "application/CALS-1840"

	// KMimeApplicationCaptiveJson
	//
	// English:
	//
	//  Application type 'captive+json'
	//
	// Português:
	//
	//  Aplicação tipo 'captive+json'
	KMimeApplicationCaptiveJson Mime = "application/captive+json"

	// KMimeApplicationCbor
	//
	// English:
	//
	//  Application type 'cbor'
	//
	// Português:
	//
	//  Aplicação tipo 'cbor'
	KMimeApplicationCbor Mime = "application/cbor"

	// KMimeApplicationCborSeq
	//
	// English:
	//
	//  Application type 'cbor-seq'
	//
	// Português:
	//
	//  Aplicação tipo 'cbor-seq'
	KMimeApplicationCborSeq Mime = "application/cbor-seq"

	// KMimeApplicationCccex
	//
	// English:
	//
	//  Application type 'cccex'
	//
	// Português:
	//
	//  Aplicação tipo 'cccex'
	KMimeApplicationCccex Mime = "application/cccex"

	// KMimeApplicationCcmpXml
	//
	// English:
	//
	//  Application type 'ccmp+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'ccmp+xml'
	KMimeApplicationCcmpXml Mime = "application/ccmp+xml"

	// KMimeApplicationCcxmlXml
	//
	// English:
	//
	//  Application type 'ccxml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'ccxml+xml'
	KMimeApplicationCcxmlXml Mime = "application/ccxml+xml"

	// KMimeApplicationCdaXml
	//
	// English:
	//
	//  Application type 'cda+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'cda+xml'
	KMimeApplicationCdaXml Mime = "application/cda+xml"

	// KMimeApplicationCDFXXML
	//
	// English:
	//
	//  Application type 'CDFX+XML'
	//
	// Português:
	//
	//  Aplicação tipo 'CDFX+XML'
	KMimeApplicationCDFXXML Mime = "application/CDFX+XML"

	// KMimeApplicationCdmiCapability
	//
	// English:
	//
	//  Application type 'cdmi-capability'
	//
	// Português:
	//
	//  Aplicação tipo 'cdmi-capability'
	KMimeApplicationCdmiCapability Mime = "application/cdmi-capability"

	// KMimeApplicationCdmiContainer
	//
	// English:
	//
	//  Application type 'cdmi-container'
	//
	// Português:
	//
	//  Aplicação tipo 'cdmi-container'
	KMimeApplicationCdmiContainer Mime = "application/cdmi-container"

	// KMimeApplicationCdmiDomain
	//
	// English:
	//
	//  Application type 'cdmi-domain'
	//
	// Português:
	//
	//  Aplicação tipo 'cdmi-domain'
	KMimeApplicationCdmiDomain Mime = "application/cdmi-domain"

	// KMimeApplicationCdmiObject
	//
	// English:
	//
	//  Application type 'cdmi-object'
	//
	// Português:
	//
	//  Aplicação tipo 'cdmi-object'
	KMimeApplicationCdmiObject Mime = "application/cdmi-object"

	// KMimeApplicationCdmiQueue
	//
	// English:
	//
	//  Application type 'cdmi-queue'
	//
	// Português:
	//
	//  Aplicação tipo 'cdmi-queue'
	KMimeApplicationCdmiQueue Mime = "application/cdmi-queue"

	// KMimeApplicationCdni
	//
	// English:
	//
	//  Application type 'cdni'
	//
	// Português:
	//
	//  Aplicação tipo 'cdni'
	KMimeApplicationCdni Mime = "application/cdni"

	// KMimeApplicationCEA
	//
	// English:
	//
	//  Application type 'CEA'
	//
	// Português:
	//
	//  Aplicação tipo 'CEA'
	KMimeApplicationCEA Mime = "application/CEA"

	// KMimeApplicationCea2018Xml
	//
	// English:
	//
	//  Application type 'cea-2018+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'cea-2018+xml'
	KMimeApplicationCea2018Xml Mime = "application/cea-2018+xml"

	// KMimeApplicationCellmlXml
	//
	// English:
	//
	//  Application type 'cellml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'cellml+xml'
	KMimeApplicationCellmlXml Mime = "application/cellml+xml"

	// KMimeApplicationCfw
	//
	// English:
	//
	//  Application type 'cfw'
	//
	// Português:
	//
	//  Aplicação tipo 'cfw'
	KMimeApplicationCfw Mime = "application/cfw"

	// KMimeApplicationCityJson
	//
	// English:
	//
	//  Application type 'city+json'
	//
	// Português:
	//
	//  Aplicação tipo 'city+json'
	KMimeApplicationCityJson Mime = "application/city+json"

	// KMimeApplicationClr
	//
	// English:
	//
	//  Application type 'clr'
	//
	// Português:
	//
	//  Aplicação tipo 'clr'
	KMimeApplicationClr Mime = "application/clr"

	// KMimeApplicationClueInfoXml
	//
	// English:
	//
	//  Application type 'clue_info+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'clue_info+xml'
	KMimeApplicationClueInfoXml Mime = "application/clue_info+xml"

	// KMimeApplicationClueXml
	//
	// English:
	//
	//  Application type 'clue+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'clue+xml'
	KMimeApplicationClueXml Mime = "application/clue+xml"

	// KMimeApplicationCms
	//
	// English:
	//
	//  Application type 'cms'
	//
	// Português:
	//
	//  Aplicação tipo 'cms'
	KMimeApplicationCms Mime = "application/cms"

	// KMimeApplicationCnrpXml
	//
	// English:
	//
	//  Application type 'cnrp+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'cnrp+xml'
	KMimeApplicationCnrpXml Mime = "application/cnrp+xml"

	// KMimeApplicationCoapGroupJson
	//
	// English:
	//
	//  Application type 'coap-group+json'
	//
	// Português:
	//
	//  Aplicação tipo 'coap-group+json'
	KMimeApplicationCoapGroupJson Mime = "application/coap-group+json"

	// KMimeApplicationCoapPayload
	//
	// English:
	//
	//  Application type 'coap-payload'
	//
	// Português:
	//
	//  Aplicação tipo 'coap-payload'
	KMimeApplicationCoapPayload Mime = "application/coap-payload"

	// KMimeApplicationCommonground
	//
	// English:
	//
	//  Application type 'commonground'
	//
	// Português:
	//
	//  Aplicação tipo 'commonground'
	KMimeApplicationCommonground Mime = "application/commonground"

	// KMimeApplicationConferenceInfoXml
	//
	// English:
	//
	//  Application type 'conference-info+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'conference-info+xml'
	KMimeApplicationConferenceInfoXml Mime = "application/conference-info+xml"

	// KMimeApplicationCplXml
	//
	// English:
	//
	//  Application type 'cpl+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'cpl+xml'
	KMimeApplicationCplXml Mime = "application/cpl+xml"

	// KMimeApplicationCose
	//
	// English:
	//
	//  Application type 'cose'
	//
	// Português:
	//
	//  Aplicação tipo 'cose'
	KMimeApplicationCose Mime = "application/cose"

	// KMimeApplicationCoseKey
	//
	// English:
	//
	//  Application type 'cose-key'
	//
	// Português:
	//
	//  Aplicação tipo 'cose-key'
	KMimeApplicationCoseKey Mime = "application/cose-key"

	// KMimeApplicationCoseKeySet
	//
	// English:
	//
	//  Application type 'cose-key-set'
	//
	// Português:
	//
	//  Aplicação tipo 'cose-key-set'
	KMimeApplicationCoseKeySet Mime = "application/cose-key-set"

	// KMimeApplicationCsrattrs
	//
	// English:
	//
	//  Application type 'csrattrs'
	//
	// Português:
	//
	//  Aplicação tipo 'csrattrs'
	KMimeApplicationCsrattrs Mime = "application/csrattrs"

	// KMimeApplicationCstaXml
	//
	// English:
	//
	//  Application type 'csta+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'csta+xml'
	KMimeApplicationCstaXml Mime = "application/csta+xml"

	// KMimeApplicationCSTAdataXml
	//
	// English:
	//
	//  Application type 'CSTAdata+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'CSTAdata+xml'
	KMimeApplicationCSTAdataXml Mime = "application/CSTAdata+xml"

	// KMimeApplicationCsvmJson
	//
	// English:
	//
	//  Application type 'csvm+json'
	//
	// Português:
	//
	//  Aplicação tipo 'csvm+json'
	KMimeApplicationCsvmJson Mime = "application/csvm+json"

	// KMimeApplicationCwt
	//
	// English:
	//
	//  Application type 'cwt'
	//
	// Português:
	//
	//  Aplicação tipo 'cwt'
	KMimeApplicationCwt Mime = "application/cwt"

	// KMimeApplicationCybercash
	//
	// English:
	//
	//  Application type 'cybercash'
	//
	// Português:
	//
	//  Aplicação tipo 'cybercash'
	KMimeApplicationCybercash Mime = "application/cybercash"

	// KMimeApplicationDashXml
	//
	// English:
	//
	//  Application type 'dash+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'dash+xml'
	KMimeApplicationDashXml Mime = "application/dash+xml"

	// KMimeApplicationDashPatchXml
	//
	// English:
	//
	//  Application type 'dash-patch+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'dash-patch+xml'
	KMimeApplicationDashPatchXml Mime = "application/dash-patch+xml"

	// KMimeApplicationDashdelta
	//
	// English:
	//
	//  Application type 'dashdelta'
	//
	// Português:
	//
	//  Aplicação tipo 'dashdelta'
	KMimeApplicationDashdelta Mime = "application/dashdelta"

	// KMimeApplicationDavmountXml
	//
	// English:
	//
	//  Application type 'davmount+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'davmount+xml'
	KMimeApplicationDavmountXml Mime = "application/davmount+xml"

	// KMimeApplicationDcaRft
	//
	// English:
	//
	//  Application type 'dca-rft'
	//
	// Português:
	//
	//  Aplicação tipo 'dca-rft'
	KMimeApplicationDcaRft Mime = "application/dca-rft"

	// KMimeApplicationDCD
	//
	// English:
	//
	//  Application type 'DCD'
	//
	// Português:
	//
	//  Aplicação tipo 'DCD'
	KMimeApplicationDCD Mime = "application/DCD"

	// KMimeApplicationDecDx
	//
	// English:
	//
	//  Application type 'dec-dx'
	//
	// Português:
	//
	//  Aplicação tipo 'dec-dx'
	KMimeApplicationDecDx Mime = "application/dec-dx"

	// KMimeApplicationDialogInfoXml
	//
	// English:
	//
	//  Application type 'dialog-info+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'dialog-info+xml'
	KMimeApplicationDialogInfoXml Mime = "application/dialog-info+xml"

	// KMimeApplicationDicom
	//
	// English:
	//
	//  Application type 'dicom'
	//
	// Português:
	//
	//  Aplicação tipo 'dicom'
	KMimeApplicationDicom Mime = "application/dicom"

	// KMimeApplicationDicomJson
	//
	// English:
	//
	//  Application type 'dicom+json'
	//
	// Português:
	//
	//  Aplicação tipo 'dicom+json'
	KMimeApplicationDicomJson Mime = "application/dicom+json"

	// KMimeApplicationDicomXml
	//
	// English:
	//
	//  Application type 'dicom+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'dicom+xml'
	KMimeApplicationDicomXml Mime = "application/dicom+xml"

	// KMimeApplicationDII
	//
	// English:
	//
	//  Application type 'DII'
	//
	// Português:
	//
	//  Aplicação tipo 'DII'
	KMimeApplicationDII Mime = "application/DII"

	// KMimeApplicationDIT
	//
	// English:
	//
	//  Application type 'DIT'
	//
	// Português:
	//
	//  Aplicação tipo 'DIT'
	KMimeApplicationDIT Mime = "application/DIT"

	// KMimeApplicationDns
	//
	// English:
	//
	//  Application type 'dns'
	//
	// Português:
	//
	//  Aplicação tipo 'dns'
	KMimeApplicationDns Mime = "application/dns"

	// KMimeApplicationDnsJson
	//
	// English:
	//
	//  Application type 'dns+json'
	//
	// Português:
	//
	//  Aplicação tipo 'dns+json'
	KMimeApplicationDnsJson Mime = "application/dns+json"

	// KMimeApplicationDnsMessage
	//
	// English:
	//
	//  Application type 'dns-message'
	//
	// Português:
	//
	//  Aplicação tipo 'dns-message'
	KMimeApplicationDnsMessage Mime = "application/dns-message"

	// KMimeApplicationDotsCbor
	//
	// English:
	//
	//  Application type 'dots+cbor'
	//
	// Português:
	//
	//  Aplicação tipo 'dots+cbor'
	KMimeApplicationDotsCbor Mime = "application/dots+cbor"

	// KMimeApplicationDskppXml
	//
	// English:
	//
	//  Application type 'dskpp+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'dskpp+xml'
	KMimeApplicationDskppXml Mime = "application/dskpp+xml"

	// KMimeApplicationDsscDer
	//
	// English:
	//
	//  Application type 'dssc+der'
	//
	// Português:
	//
	//  Aplicação tipo 'dssc+der'
	KMimeApplicationDsscDer Mime = "application/dssc+der"

	// KMimeApplicationDsscXml
	//
	// English:
	//
	//  Application type 'dssc+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'dssc+xml'
	KMimeApplicationDsscXml Mime = "application/dssc+xml"

	// KMimeApplicationDvcs
	//
	// English:
	//
	//  Application type 'dvcs'
	//
	// Português:
	//
	//  Aplicação tipo 'dvcs'
	KMimeApplicationDvcs Mime = "application/dvcs"

	// KMimeApplicationEcmascript
	//
	// English:
	//
	//  Application type 'ecmascript'
	//
	// Português:
	//
	//  Aplicação tipo 'ecmascript'
	KMimeApplicationEcmascript Mime = "(OBSOLETED"

	// KMimeApplicationEDIConsent
	//
	// English:
	//
	//  Application type 'EDI-consent'
	//
	// Português:
	//
	//  Aplicação tipo 'EDI-consent'
	KMimeApplicationEDIConsent Mime = "application/EDI-consent"

	// KMimeApplicationEDIFACT
	//
	// English:
	//
	//  Application type 'EDIFACT'
	//
	// Português:
	//
	//  Aplicação tipo 'EDIFACT'
	KMimeApplicationEDIFACT Mime = "application/EDIFACT"

	// KMimeApplicationEDIX12
	//
	// English:
	//
	//  Application type 'EDI-X12'
	//
	// Português:
	//
	//  Aplicação tipo 'EDI-X12'
	KMimeApplicationEDIX12 Mime = "application/EDI-X12"

	// KMimeApplicationEfi
	//
	// English:
	//
	//  Application type 'efi'
	//
	// Português:
	//
	//  Aplicação tipo 'efi'
	KMimeApplicationEfi Mime = "application/efi"

	// KMimeApplicationElmJson
	//
	// English:
	//
	//  Application type 'elm+json'
	//
	// Português:
	//
	//  Aplicação tipo 'elm+json'
	KMimeApplicationElmJson Mime = "application/elm+json"

	// KMimeApplicationElmXml
	//
	// English:
	//
	//  Application type 'elm+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'elm+xml'
	KMimeApplicationElmXml Mime = "application/elm+xml"

	// KMimeApplicationEmergencyCallDataCapXml
	//
	// English:
	//
	//  Application type 'EmergencyCallData.cap+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'EmergencyCallData.cap+xml'
	KMimeApplicationEmergencyCallDataCapXml Mime = "application/EmergencyCallData.cap+xml"

	// KMimeApplicationEmergencyCallDataCommentXml
	//
	// English:
	//
	//  Application type 'EmergencyCallData.Comment+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'EmergencyCallData.Comment+xml'
	KMimeApplicationEmergencyCallDataCommentXml Mime = "application/EmergencyCallData.Comment+xml"

	// KMimeApplicationEmergencyCallDataControlXml
	//
	// English:
	//
	//  Application type 'EmergencyCallData.Control+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'EmergencyCallData.Control+xml'
	KMimeApplicationEmergencyCallDataControlXml Mime = "application/EmergencyCallData.Control+xml"

	// KMimeApplicationEmergencyCallDataDeviceInfoXml
	//
	// English:
	//
	//  Application type 'EmergencyCallData.DeviceInfo+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'EmergencyCallData.DeviceInfo+xml'
	KMimeApplicationEmergencyCallDataDeviceInfoXml Mime = "application/EmergencyCallData.DeviceInfo+xml"

	// KMimeApplicationEmergencyCallDataECallMSD
	//
	// English:
	//
	//  Application type 'EmergencyCallData.eCall.MSD'
	//
	// Português:
	//
	//  Aplicação tipo 'EmergencyCallData.eCall.MSD'
	KMimeApplicationEmergencyCallDataECallMSD Mime = "application/EmergencyCallData.eCall.MSD"

	// KMimeApplicationEmergencyCallDataProviderInfoXml
	//
	// English:
	//
	//  Application type 'EmergencyCallData.ProviderInfo+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'EmergencyCallData.ProviderInfo+xml'
	KMimeApplicationEmergencyCallDataProviderInfoXml Mime = "application/EmergencyCallData.ProviderInfo+xml"

	// KMimeApplicationEmergencyCallDataServiceInfoXml
	//
	// English:
	//
	//  Application type 'EmergencyCallData.ServiceInfo+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'EmergencyCallData.ServiceInfo+xml'
	KMimeApplicationEmergencyCallDataServiceInfoXml Mime = "application/EmergencyCallData.ServiceInfo+xml"

	// KMimeApplicationEmergencyCallDataSubscriberInfoXml
	//
	// English:
	//
	//  Application type 'EmergencyCallData.SubscriberInfo+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'EmergencyCallData.SubscriberInfo+xml'
	KMimeApplicationEmergencyCallDataSubscriberInfoXml Mime = "application/EmergencyCallData.SubscriberInfo+xml"

	// KMimeApplicationEmergencyCallDataVEDSXml
	//
	// English:
	//
	//  Application type 'EmergencyCallData.VEDS+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'EmergencyCallData.VEDS+xml'
	KMimeApplicationEmergencyCallDataVEDSXml Mime = "application/EmergencyCallData.VEDS+xml"

	// KMimeApplicationEmmaXml
	//
	// English:
	//
	//  Application type 'emma+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'emma+xml'
	KMimeApplicationEmmaXml Mime = "application/emma+xml"

	// KMimeApplicationEmotionmlXml
	//
	// English:
	//
	//  Application type 'emotionml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'emotionml+xml'
	KMimeApplicationEmotionmlXml Mime = "application/emotionml+xml"

	// KMimeApplicationEncaprtp
	//
	// English:
	//
	//  Application type 'encaprtp'
	//
	// Português:
	//
	//  Aplicação tipo 'encaprtp'
	KMimeApplicationEncaprtp Mime = "application/encaprtp"

	// KMimeApplicationEppXml
	//
	// English:
	//
	//  Application type 'epp+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'epp+xml'
	KMimeApplicationEppXml Mime = "application/epp+xml"

	// KMimeApplicationEpubZip
	//
	// English:
	//
	//  Application type 'epub+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'epub+zip'
	KMimeApplicationEpubZip Mime = "application/epub+zip"

	// KMimeApplicationEshop
	//
	// English:
	//
	//  Application type 'eshop'
	//
	// Português:
	//
	//  Aplicação tipo 'eshop'
	KMimeApplicationEshop Mime = "application/eshop"

	// KMimeApplicationExample
	//
	// English:
	//
	//  Application type 'example'
	//
	// Português:
	//
	//  Aplicação tipo 'example'
	KMimeApplicationExample Mime = "application/example"

	// KMimeApplicationExi
	//
	// English:
	//
	//  Application type 'exi'
	//
	// Português:
	//
	//  Aplicação tipo 'exi'
	KMimeApplicationExi Mime = "application/exi"

	// KMimeApplicationExpectCtReportJson
	//
	// English:
	//
	//  Application type 'expect-ct-report+json'
	//
	// Português:
	//
	//  Aplicação tipo 'expect-ct-report+json'
	KMimeApplicationExpectCtReportJson Mime = "application/expect-ct-report+json"

	// KMimeApplicationExpress
	//
	// English:
	//
	//  Application type 'express'
	//
	// Português:
	//
	//  Aplicação tipo 'express'
	KMimeApplicationExpress Mime = "application/express"

	// KMimeApplicationFastinfoset
	//
	// English:
	//
	//  Application type 'fastinfoset'
	//
	// Português:
	//
	//  Aplicação tipo 'fastinfoset'
	KMimeApplicationFastinfoset Mime = "application/fastinfoset"

	// KMimeApplicationFastsoap
	//
	// English:
	//
	//  Application type 'fastsoap'
	//
	// Português:
	//
	//  Aplicação tipo 'fastsoap'
	KMimeApplicationFastsoap Mime = "application/fastsoap"

	// KMimeApplicationFdf
	//
	// English:
	//
	//  Application type 'fdf'
	//
	// Português:
	//
	//  Aplicação tipo 'fdf'
	KMimeApplicationFdf Mime = "application/fdf"

	// KMimeApplicationFdtXml
	//
	// English:
	//
	//  Application type 'fdt+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'fdt+xml'
	KMimeApplicationFdtXml Mime = "application/fdt+xml"

	// KMimeApplicationFhirJson
	//
	// English:
	//
	//  Application type 'fhir+json'
	//
	// Português:
	//
	//  Aplicação tipo 'fhir+json'
	KMimeApplicationFhirJson Mime = "application/fhir+json"

	// KMimeApplicationFhirXml
	//
	// English:
	//
	//  Application type 'fhir+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'fhir+xml'
	KMimeApplicationFhirXml Mime = "application/fhir+xml"

	// KMimeApplicationFits
	//
	// English:
	//
	//  Application type 'fits'
	//
	// Português:
	//
	//  Aplicação tipo 'fits'
	KMimeApplicationFits Mime = "application/fits"

	// KMimeApplicationFlexfec
	//
	// English:
	//
	//  Application type 'flexfec'
	//
	// Português:
	//
	//  Aplicação tipo 'flexfec'
	KMimeApplicationFlexfec Mime = "application/flexfec"

	// KMimeApplicationFontSfnt
	//
	// English:
	//
	//  Application type 'font-sfnt'
	//
	// Português:
	//
	//  Aplicação tipo 'font-sfnt'
	KMimeApplicationFontSfnt Mime = "-"

	// KMimeApplicationFontTdpfr
	//
	// English:
	//
	//  Application type 'font-tdpfr'
	//
	// Português:
	//
	//  Aplicação tipo 'font-tdpfr'
	KMimeApplicationFontTdpfr Mime = "application/font-tdpfr"

	// KMimeApplicationFontWoff
	//
	// English:
	//
	//  Application type 'font-woff'
	//
	// Português:
	//
	//  Aplicação tipo 'font-woff'
	KMimeApplicationFontWoff Mime = "-"

	// KMimeApplicationFrameworkAttributesXml
	//
	// English:
	//
	//  Application type 'framework-attributes+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'framework-attributes+xml'
	KMimeApplicationFrameworkAttributesXml Mime = "application/framework-attributes+xml"

	// KMimeApplicationGeoJson
	//
	// English:
	//
	//  Application type 'geo+json'
	//
	// Português:
	//
	//  Aplicação tipo 'geo+json'
	KMimeApplicationGeoJson Mime = "application/geo+json"

	// KMimeApplicationGeoJsonSeq
	//
	// English:
	//
	//  Application type 'geo+json-seq'
	//
	// Português:
	//
	//  Aplicação tipo 'geo+json-seq'
	KMimeApplicationGeoJsonSeq Mime = "application/geo+json-seq"

	// KMimeApplicationGeopackageSqlite3
	//
	// English:
	//
	//  Application type 'geopackage+sqlite3'
	//
	// Português:
	//
	//  Aplicação tipo 'geopackage+sqlite3'
	KMimeApplicationGeopackageSqlite3 Mime = "application/geopackage+sqlite3"

	// KMimeApplicationGeoxacmlXml
	//
	// English:
	//
	//  Application type 'geoxacml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'geoxacml+xml'
	KMimeApplicationGeoxacmlXml Mime = "application/geoxacml+xml"

	// KMimeApplicationGltfBuffer
	//
	// English:
	//
	//  Application type 'gltf-buffer'
	//
	// Português:
	//
	//  Aplicação tipo 'gltf-buffer'
	KMimeApplicationGltfBuffer Mime = "application/gltf-buffer"

	// KMimeApplicationGmlXml
	//
	// English:
	//
	//  Application type 'gml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'gml+xml'
	KMimeApplicationGmlXml Mime = "application/gml+xml"

	// KMimeApplicationGzip
	//
	// English:
	//
	//  Application type 'gzip'
	//
	// Português:
	//
	//  Aplicação tipo 'gzip'
	KMimeApplicationGzip Mime = "application/gzip"

	// KMimeApplicationH224
	//
	// English:
	//
	//  Application type 'H224'
	//
	// Português:
	//
	//  Aplicação tipo 'H224'
	KMimeApplicationH224 Mime = "application/H224"

	// KMimeApplicationHeldXml
	//
	// English:
	//
	//  Application type 'held+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'held+xml'
	KMimeApplicationHeldXml Mime = "application/held+xml"

	// KMimeApplicationHl7v2Xml
	//
	// English:
	//
	//  Application type 'hl7v2+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'hl7v2+xml'
	KMimeApplicationHl7v2Xml Mime = "application/hl7v2+xml"

	// KMimeApplicationHttp
	//
	// English:
	//
	//  Application type 'http'
	//
	// Português:
	//
	//  Aplicação tipo 'http'
	KMimeApplicationHttp Mime = "application/http"

	// KMimeApplicationHyperstudio
	//
	// English:
	//
	//  Application type 'hyperstudio'
	//
	// Português:
	//
	//  Aplicação tipo 'hyperstudio'
	KMimeApplicationHyperstudio Mime = "application/hyperstudio"

	// KMimeApplicationIbeKeyRequestXml
	//
	// English:
	//
	//  Application type 'ibe-key-request+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'ibe-key-request+xml'
	KMimeApplicationIbeKeyRequestXml Mime = "application/ibe-key-request+xml"

	// KMimeApplicationIbePkgReplyXml
	//
	// English:
	//
	//  Application type 'ibe-pkg-reply+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'ibe-pkg-reply+xml'
	KMimeApplicationIbePkgReplyXml Mime = "application/ibe-pkg-reply+xml"

	// KMimeApplicationIbePpData
	//
	// English:
	//
	//  Application type 'ibe-pp-data'
	//
	// Português:
	//
	//  Aplicação tipo 'ibe-pp-data'
	KMimeApplicationIbePpData Mime = "application/ibe-pp-data"

	// KMimeApplicationIges
	//
	// English:
	//
	//  Application type 'iges'
	//
	// Português:
	//
	//  Aplicação tipo 'iges'
	KMimeApplicationIges Mime = "application/iges"

	// KMimeApplicationImIscomposingXml
	//
	// English:
	//
	//  Application type 'im-iscomposing+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'im-iscomposing+xml'
	KMimeApplicationImIscomposingXml Mime = "application/im-iscomposing+xml"

	// KMimeApplicationIndex
	//
	// English:
	//
	//  Application type 'index'
	//
	// Português:
	//
	//  Aplicação tipo 'index'
	KMimeApplicationIndex Mime = "application/index"

	// KMimeApplicationIndexCmd
	//
	// English:
	//
	//  Application type 'index.cmd'
	//
	// Português:
	//
	//  Aplicação tipo 'index.cmd'
	KMimeApplicationIndexCmd Mime = "application/index.cmd"

	// KMimeApplicationIndexObj
	//
	// English:
	//
	//  Application type 'index.obj'
	//
	// Português:
	//
	//  Aplicação tipo 'index.obj'
	KMimeApplicationIndexObj Mime = "application/index.obj"

	// KMimeApplicationIndexResponse
	//
	// English:
	//
	//  Application type 'index.response'
	//
	// Português:
	//
	//  Aplicação tipo 'index.response'
	KMimeApplicationIndexResponse Mime = "application/index.response"

	// KMimeApplicationIndexVnd
	//
	// English:
	//
	//  Application type 'index.vnd'
	//
	// Português:
	//
	//  Aplicação tipo 'index.vnd'
	KMimeApplicationIndexVnd Mime = "application/index.vnd"

	// KMimeApplicationInkmlXml
	//
	// English:
	//
	//  Application type 'inkml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'inkml+xml'
	KMimeApplicationInkmlXml Mime = "application/inkml+xml"

	// KMimeApplicationIOTP
	//
	// English:
	//
	//  Application type 'IOTP'
	//
	// Português:
	//
	//  Aplicação tipo 'IOTP'
	KMimeApplicationIOTP Mime = "application/IOTP"

	// KMimeApplicationIpfix
	//
	// English:
	//
	//  Application type 'ipfix'
	//
	// Português:
	//
	//  Aplicação tipo 'ipfix'
	KMimeApplicationIpfix Mime = "application/ipfix"

	// KMimeApplicationIpp
	//
	// English:
	//
	//  Application type 'ipp'
	//
	// Português:
	//
	//  Aplicação tipo 'ipp'
	KMimeApplicationIpp Mime = "application/ipp"

	// KMimeApplicationISUP
	//
	// English:
	//
	//  Application type 'ISUP'
	//
	// Português:
	//
	//  Aplicação tipo 'ISUP'
	KMimeApplicationISUP Mime = "application/ISUP"

	// KMimeApplicationItsXml
	//
	// English:
	//
	//  Application type 'its+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'its+xml'
	KMimeApplicationItsXml Mime = "application/its+xml"

	// KMimeApplicationJavascript
	//
	// English:
	//
	//  Application type 'javascript'
	//
	// Português:
	//
	//  Aplicação tipo 'javascript'
	KMimeApplicationJavascript Mime = "(OBSOLETED"

	// KMimeApplicationJf2feedJson
	//
	// English:
	//
	//  Application type 'jf2feed+json'
	//
	// Português:
	//
	//  Aplicação tipo 'jf2feed+json'
	KMimeApplicationJf2feedJson Mime = "application/jf2feed+json"

	// KMimeApplicationJose
	//
	// English:
	//
	//  Application type 'jose'
	//
	// Português:
	//
	//  Aplicação tipo 'jose'
	KMimeApplicationJose Mime = "application/jose"

	// KMimeApplicationJoseJson
	//
	// English:
	//
	//  Application type 'jose+json'
	//
	// Português:
	//
	//  Aplicação tipo 'jose+json'
	KMimeApplicationJoseJson Mime = "application/jose+json"

	// KMimeApplicationJrdJson
	//
	// English:
	//
	//  Application type 'jrd+json'
	//
	// Português:
	//
	//  Aplicação tipo 'jrd+json'
	KMimeApplicationJrdJson Mime = "application/jrd+json"

	// KMimeApplicationJscalendarJson
	//
	// English:
	//
	//  Application type 'jscalendar+json'
	//
	// Português:
	//
	//  Aplicação tipo 'jscalendar+json'
	KMimeApplicationJscalendarJson Mime = "application/jscalendar+json"

	// KMimeApplicationJson
	//
	// English:
	//
	//  Application type 'json'
	//
	// Português:
	//
	//  Aplicação tipo 'json'
	KMimeApplicationJson Mime = "application/json"

	// KMimeApplicationJsonPatchJson
	//
	// English:
	//
	//  Application type 'json-patch+json'
	//
	// Português:
	//
	//  Aplicação tipo 'json-patch+json'
	KMimeApplicationJsonPatchJson Mime = "application/json-patch+json"

	// KMimeApplicationJsonSeq
	//
	// English:
	//
	//  Application type 'json-seq'
	//
	// Português:
	//
	//  Aplicação tipo 'json-seq'
	KMimeApplicationJsonSeq Mime = "application/json-seq"

	// KMimeApplicationJwkJson
	//
	// English:
	//
	//  Application type 'jwk+json'
	//
	// Português:
	//
	//  Aplicação tipo 'jwk+json'
	KMimeApplicationJwkJson Mime = "application/jwk+json"

	// KMimeApplicationJwkSetJson
	//
	// English:
	//
	//  Application type 'jwk-set+json'
	//
	// Português:
	//
	//  Aplicação tipo 'jwk-set+json'
	KMimeApplicationJwkSetJson Mime = "application/jwk-set+json"

	// KMimeApplicationJwt
	//
	// English:
	//
	//  Application type 'jwt'
	//
	// Português:
	//
	//  Aplicação tipo 'jwt'
	KMimeApplicationJwt Mime = "application/jwt"

	// KMimeApplicationKpmlRequestXml
	//
	// English:
	//
	//  Application type 'kpml-request+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'kpml-request+xml'
	KMimeApplicationKpmlRequestXml Mime = "application/kpml-request+xml"

	// KMimeApplicationKpmlResponseXml
	//
	// English:
	//
	//  Application type 'kpml-response+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'kpml-response+xml'
	KMimeApplicationKpmlResponseXml Mime = "application/kpml-response+xml"

	// KMimeApplicationLdJson
	//
	// English:
	//
	//  Application type 'ld+json'
	//
	// Português:
	//
	//  Aplicação tipo 'ld+json'
	KMimeApplicationLdJson Mime = "application/ld+json"

	// KMimeApplicationLgrXml
	//
	// English:
	//
	//  Application type 'lgr+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'lgr+xml'
	KMimeApplicationLgrXml Mime = "application/lgr+xml"

	// KMimeApplicationLinkFormat
	//
	// English:
	//
	//  Application type 'link-format'
	//
	// Português:
	//
	//  Aplicação tipo 'link-format'
	KMimeApplicationLinkFormat Mime = "application/link-format"

	// KMimeApplicationLoadControlXml
	//
	// English:
	//
	//  Application type 'load-control+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'load-control+xml'
	KMimeApplicationLoadControlXml Mime = "application/load-control+xml"

	// KMimeApplicationLostXml
	//
	// English:
	//
	//  Application type 'lost+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'lost+xml'
	KMimeApplicationLostXml Mime = "application/lost+xml"

	// KMimeApplicationLostsyncXml
	//
	// English:
	//
	//  Application type 'lostsync+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'lostsync+xml'
	KMimeApplicationLostsyncXml Mime = "application/lostsync+xml"

	// KMimeApplicationLpfZip
	//
	// English:
	//
	//  Application type 'lpf+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'lpf+zip'
	KMimeApplicationLpfZip Mime = "application/lpf+zip"

	// KMimeApplicationLXF
	//
	// English:
	//
	//  Application type 'LXF'
	//
	// Português:
	//
	//  Aplicação tipo 'LXF'
	KMimeApplicationLXF Mime = "application/LXF"

	// KMimeApplicationMacBinhex40
	//
	// English:
	//
	//  Application type 'mac-binhex40'
	//
	// Português:
	//
	//  Aplicação tipo 'mac-binhex40'
	KMimeApplicationMacBinhex40 Mime = "application/mac-binhex40"

	// KMimeApplicationMacwriteii
	//
	// English:
	//
	//  Application type 'macwriteii'
	//
	// Português:
	//
	//  Aplicação tipo 'macwriteii'
	KMimeApplicationMacwriteii Mime = "application/macwriteii"

	// KMimeApplicationMadsXml
	//
	// English:
	//
	//  Application type 'mads+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mads+xml'
	KMimeApplicationMadsXml Mime = "application/mads+xml"

	// KMimeApplicationManifestJson
	//
	// English:
	//
	//  Application type 'manifest+json'
	//
	// Português:
	//
	//  Aplicação tipo 'manifest+json'
	KMimeApplicationManifestJson Mime = "application/manifest+json"

	// KMimeApplicationMarc
	//
	// English:
	//
	//  Application type 'marc'
	//
	// Português:
	//
	//  Aplicação tipo 'marc'
	KMimeApplicationMarc Mime = "application/marc"

	// KMimeApplicationMarcxmlXml
	//
	// English:
	//
	//  Application type 'marcxml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'marcxml+xml'
	KMimeApplicationMarcxmlXml Mime = "application/marcxml+xml"

	// KMimeApplicationMathematica
	//
	// English:
	//
	//  Application type 'mathematica'
	//
	// Português:
	//
	//  Aplicação tipo 'mathematica'
	KMimeApplicationMathematica Mime = "application/mathematica"

	// KMimeApplicationMathmlXml
	//
	// English:
	//
	//  Application type 'mathml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mathml+xml'
	KMimeApplicationMathmlXml Mime = "application/mathml+xml"

	// KMimeApplicationMathmlContentXml
	//
	// English:
	//
	//  Application type 'mathml-content+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mathml-content+xml'
	KMimeApplicationMathmlContentXml Mime = "application/mathml-content+xml"

	// KMimeApplicationMathmlPresentationXml
	//
	// English:
	//
	//  Application type 'mathml-presentation+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mathml-presentation+xml'
	KMimeApplicationMathmlPresentationXml Mime = "application/mathml-presentation+xml"

	// KMimeApplicationMbmsAssociatedProcedureDescriptionXml
	//
	// English:
	//
	//  Application type 'mbms-associated-procedure-description+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mbms-associated-procedure-description+xml'
	KMimeApplicationMbmsAssociatedProcedureDescriptionXml Mime = "application/mbms-associated-procedure-description+xml"

	// KMimeApplicationMbmsDeregisterXml
	//
	// English:
	//
	//  Application type 'mbms-deregister+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mbms-deregister+xml'
	KMimeApplicationMbmsDeregisterXml Mime = "application/mbms-deregister+xml"

	// KMimeApplicationMbmsEnvelopeXml
	//
	// English:
	//
	//  Application type 'mbms-envelope+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mbms-envelope+xml'
	KMimeApplicationMbmsEnvelopeXml Mime = "application/mbms-envelope+xml"

	// KMimeApplicationMbmsMskResponseXml
	//
	// English:
	//
	//  Application type 'mbms-msk-response+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mbms-msk-response+xml'
	KMimeApplicationMbmsMskResponseXml Mime = "application/mbms-msk-response+xml"

	// KMimeApplicationMbmsMskXml
	//
	// English:
	//
	//  Application type 'mbms-msk+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mbms-msk+xml'
	KMimeApplicationMbmsMskXml Mime = "application/mbms-msk+xml"

	// KMimeApplicationMbmsProtectionDescriptionXml
	//
	// English:
	//
	//  Application type 'mbms-protection-description+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mbms-protection-description+xml'
	KMimeApplicationMbmsProtectionDescriptionXml Mime = "application/mbms-protection-description+xml"

	// KMimeApplicationMbmsReceptionReportXml
	//
	// English:
	//
	//  Application type 'mbms-reception-report+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mbms-reception-report+xml'
	KMimeApplicationMbmsReceptionReportXml Mime = "application/mbms-reception-report+xml"

	// KMimeApplicationMbmsRegisterResponseXml
	//
	// English:
	//
	//  Application type 'mbms-register-response+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mbms-register-response+xml'
	KMimeApplicationMbmsRegisterResponseXml Mime = "application/mbms-register-response+xml"

	// KMimeApplicationMbmsRegisterXml
	//
	// English:
	//
	//  Application type 'mbms-register+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mbms-register+xml'
	KMimeApplicationMbmsRegisterXml Mime = "application/mbms-register+xml"

	// KMimeApplicationMbmsScheduleXml
	//
	// English:
	//
	//  Application type 'mbms-schedule+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mbms-schedule+xml'
	KMimeApplicationMbmsScheduleXml Mime = "application/mbms-schedule+xml"

	// KMimeApplicationMbmsUserServiceDescriptionXml
	//
	// English:
	//
	//  Application type 'mbms-user-service-description+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mbms-user-service-description+xml'
	KMimeApplicationMbmsUserServiceDescriptionXml Mime = "application/mbms-user-service-description+xml"

	// KMimeApplicationMbox
	//
	// English:
	//
	//  Application type 'mbox'
	//
	// Português:
	//
	//  Aplicação tipo 'mbox'
	KMimeApplicationMbox Mime = "application/mbox"

	// KMimeApplicationMediaControlXml
	//
	// English:
	//
	//  Application type 'media_control+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'media_control+xml'
	KMimeApplicationMediaControlXml Mime = "application/media_control+xml"

	// KMimeApplicationMediaPolicyDatasetXml
	//
	// English:
	//
	//  Application type 'media-policy-dataset+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'media-policy-dataset+xml'
	KMimeApplicationMediaPolicyDatasetXml Mime = "application/media-policy-dataset+xml"

	// KMimeApplicationMediaservercontrolXml
	//
	// English:
	//
	//  Application type 'mediaservercontrol+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mediaservercontrol+xml'
	KMimeApplicationMediaservercontrolXml Mime = "application/mediaservercontrol+xml"

	// KMimeApplicationMergePatchJson
	//
	// English:
	//
	//  Application type 'merge-patch+json'
	//
	// Português:
	//
	//  Aplicação tipo 'merge-patch+json'
	KMimeApplicationMergePatchJson Mime = "application/merge-patch+json"

	// KMimeApplicationMetalink4Xml
	//
	// English:
	//
	//  Application type 'metalink4+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'metalink4+xml'
	KMimeApplicationMetalink4Xml Mime = "application/metalink4+xml"

	// KMimeApplicationMetsXml
	//
	// English:
	//
	//  Application type 'mets+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mets+xml'
	KMimeApplicationMetsXml Mime = "application/mets+xml"

	// KMimeApplicationMF4
	//
	// English:
	//
	//  Application type 'MF4'
	//
	// Português:
	//
	//  Aplicação tipo 'MF4'
	KMimeApplicationMF4 Mime = "application/MF4"

	// KMimeApplicationMikey
	//
	// English:
	//
	//  Application type 'mikey'
	//
	// Português:
	//
	//  Aplicação tipo 'mikey'
	KMimeApplicationMikey Mime = "application/mikey"

	// KMimeApplicationMipc
	//
	// English:
	//
	//  Application type 'mipc'
	//
	// Português:
	//
	//  Aplicação tipo 'mipc'
	KMimeApplicationMipc Mime = "application/mipc"

	// KMimeApplicationMissingBlocksCborSeq
	//
	// English:
	//
	//  Application type 'missing-blocks+cbor-seq'
	//
	// Português:
	//
	//  Aplicação tipo 'missing-blocks+cbor-seq'
	KMimeApplicationMissingBlocksCborSeq Mime = "application/missing-blocks+cbor-seq"

	// KMimeApplicationMmtAeiXml
	//
	// English:
	//
	//  Application type 'mmt-aei+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mmt-aei+xml'
	KMimeApplicationMmtAeiXml Mime = "application/mmt-aei+xml"

	// KMimeApplicationMmtUsdXml
	//
	// English:
	//
	//  Application type 'mmt-usd+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mmt-usd+xml'
	KMimeApplicationMmtUsdXml Mime = "application/mmt-usd+xml"

	// KMimeApplicationModsXml
	//
	// English:
	//
	//  Application type 'mods+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mods+xml'
	KMimeApplicationModsXml Mime = "application/mods+xml"

	// KMimeApplicationMossKeys
	//
	// English:
	//
	//  Application type 'moss-keys'
	//
	// Português:
	//
	//  Aplicação tipo 'moss-keys'
	KMimeApplicationMossKeys Mime = "application/moss-keys"

	// KMimeApplicationMossSignature
	//
	// English:
	//
	//  Application type 'moss-signature'
	//
	// Português:
	//
	//  Aplicação tipo 'moss-signature'
	KMimeApplicationMossSignature Mime = "application/moss-signature"

	// KMimeApplicationMosskeyData
	//
	// English:
	//
	//  Application type 'mosskey-data'
	//
	// Português:
	//
	//  Aplicação tipo 'mosskey-data'
	KMimeApplicationMosskeyData Mime = "application/mosskey-data"

	// KMimeApplicationMosskeyRequest
	//
	// English:
	//
	//  Application type 'mosskey-request'
	//
	// Português:
	//
	//  Aplicação tipo 'mosskey-request'
	KMimeApplicationMosskeyRequest Mime = "application/mosskey-request"

	// KMimeApplicationMp21
	//
	// English:
	//
	//  Application type 'mp21'
	//
	// Português:
	//
	//  Aplicação tipo 'mp21'
	KMimeApplicationMp21 Mime = "application/mp21"

	// KMimeApplicationMp4
	//
	// English:
	//
	//  Application type 'mp4'
	//
	// Português:
	//
	//  Aplicação tipo 'mp4'
	KMimeApplicationMp4 Mime = "application/mp4"

	// KMimeApplicationMpeg4Generic
	//
	// English:
	//
	//  Application type 'mpeg4-generic'
	//
	// Português:
	//
	//  Aplicação tipo 'mpeg4-generic'
	KMimeApplicationMpeg4Generic Mime = "application/mpeg4-generic"

	// KMimeApplicationMpeg4Iod
	//
	// English:
	//
	//  Application type 'mpeg4-iod'
	//
	// Português:
	//
	//  Aplicação tipo 'mpeg4-iod'
	KMimeApplicationMpeg4Iod Mime = "application/mpeg4-iod"

	// KMimeApplicationMpeg4IodXmt
	//
	// English:
	//
	//  Application type 'mpeg4-iod-xmt'
	//
	// Português:
	//
	//  Aplicação tipo 'mpeg4-iod-xmt'
	KMimeApplicationMpeg4IodXmt Mime = "application/mpeg4-iod-xmt"

	// KMimeApplicationMrbConsumerXml
	//
	// English:
	//
	//  Application type 'mrb-consumer+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mrb-consumer+xml'
	KMimeApplicationMrbConsumerXml Mime = "application/mrb-consumer+xml"

	// KMimeApplicationMrbPublishXml
	//
	// English:
	//
	//  Application type 'mrb-publish+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mrb-publish+xml'
	KMimeApplicationMrbPublishXml Mime = "application/mrb-publish+xml"

	// KMimeApplicationMscIvrXml
	//
	// English:
	//
	//  Application type 'msc-ivr+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'msc-ivr+xml'
	KMimeApplicationMscIvrXml Mime = "application/msc-ivr+xml"

	// KMimeApplicationMscMixerXml
	//
	// English:
	//
	//  Application type 'msc-mixer+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'msc-mixer+xml'
	KMimeApplicationMscMixerXml Mime = "application/msc-mixer+xml"

	// KMimeApplicationMsword
	//
	// English:
	//
	//  Application type 'msword'
	//
	// Português:
	//
	//  Aplicação tipo 'msword'
	KMimeApplicationMsword Mime = "application/msword"

	// KMimeApplicationMudJson
	//
	// English:
	//
	//  Application type 'mud+json'
	//
	// Português:
	//
	//  Aplicação tipo 'mud+json'
	KMimeApplicationMudJson Mime = "application/mud+json"

	// KMimeApplicationMultipartCore
	//
	// English:
	//
	//  Application type 'multipart-core'
	//
	// Português:
	//
	//  Aplicação tipo 'multipart-core'
	KMimeApplicationMultipartCore Mime = "application/multipart-core"

	// KMimeApplicationMxf
	//
	// English:
	//
	//  Application type 'mxf'
	//
	// Português:
	//
	//  Aplicação tipo 'mxf'
	KMimeApplicationMxf Mime = "application/mxf"

	// KMimeApplicationNQuads
	//
	// English:
	//
	//  Application type 'n-quads'
	//
	// Português:
	//
	//  Aplicação tipo 'n-quads'
	KMimeApplicationNQuads Mime = "application/n-quads"

	// KMimeApplicationNTriples
	//
	// English:
	//
	//  Application type 'n-triples'
	//
	// Português:
	//
	//  Aplicação tipo 'n-triples'
	KMimeApplicationNTriples Mime = "application/n-triples"

	// KMimeApplicationNasdata
	//
	// English:
	//
	//  Application type 'nasdata'
	//
	// Português:
	//
	//  Aplicação tipo 'nasdata'
	KMimeApplicationNasdata Mime = "application/nasdata"

	// KMimeApplicationNewsCheckgroups
	//
	// English:
	//
	//  Application type 'news-checkgroups'
	//
	// Português:
	//
	//  Aplicação tipo 'news-checkgroups'
	KMimeApplicationNewsCheckgroups Mime = "application/news-checkgroups"

	// KMimeApplicationNewsGroupinfo
	//
	// English:
	//
	//  Application type 'news-groupinfo'
	//
	// Português:
	//
	//  Aplicação tipo 'news-groupinfo'
	KMimeApplicationNewsGroupinfo Mime = "application/news-groupinfo"

	// KMimeApplicationNewsTransmission
	//
	// English:
	//
	//  Application type 'news-transmission'
	//
	// Português:
	//
	//  Aplicação tipo 'news-transmission'
	KMimeApplicationNewsTransmission Mime = "application/news-transmission"

	// KMimeApplicationNlsmlXml
	//
	// English:
	//
	//  Application type 'nlsml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'nlsml+xml'
	KMimeApplicationNlsmlXml Mime = "application/nlsml+xml"

	// KMimeApplicationNode
	//
	// English:
	//
	//  Application type 'node'
	//
	// Português:
	//
	//  Aplicação tipo 'node'
	KMimeApplicationNode Mime = "application/node"

	// KMimeApplicationNss
	//
	// English:
	//
	//  Application type 'nss'
	//
	// Português:
	//
	//  Aplicação tipo 'nss'
	KMimeApplicationNss Mime = "application/nss"

	// KMimeApplicationOauthAuthzReqJwt
	//
	// English:
	//
	//  Application type 'oauth-authz-req+jwt'
	//
	// Português:
	//
	//  Aplicação tipo 'oauth-authz-req+jwt'
	KMimeApplicationOauthAuthzReqJwt Mime = "application/oauth-authz-req+jwt"

	// KMimeApplicationObliviousDnsMessage
	//
	// English:
	//
	//  Application type 'oblivious-dns-message'
	//
	// Português:
	//
	//  Aplicação tipo 'oblivious-dns-message'
	KMimeApplicationObliviousDnsMessage Mime = "application/oblivious-dns-message"

	// KMimeApplicationOcspRequest
	//
	// English:
	//
	//  Application type 'ocsp-request'
	//
	// Português:
	//
	//  Aplicação tipo 'ocsp-request'
	KMimeApplicationOcspRequest Mime = "application/ocsp-request"

	// KMimeApplicationOcspResponse
	//
	// English:
	//
	//  Application type 'ocsp-response'
	//
	// Português:
	//
	//  Aplicação tipo 'ocsp-response'
	KMimeApplicationOcspResponse Mime = "application/ocsp-response"

	// KMimeApplicationOctetStream
	//
	// English:
	//
	//  Application type 'octet-stream'
	//
	// Português:
	//
	//  Aplicação tipo 'octet-stream'
	KMimeApplicationOctetStream Mime = "application/octet-stream"

	// KMimeApplicationODA
	//
	// English:
	//
	//  Application type 'ODA'
	//
	// Português:
	//
	//  Aplicação tipo 'ODA'
	KMimeApplicationODA Mime = "application/ODA"

	// KMimeApplicationOdmXml
	//
	// English:
	//
	//  Application type 'odm+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'odm+xml'
	KMimeApplicationOdmXml Mime = "application/odm+xml"

	// KMimeApplicationODX
	//
	// English:
	//
	//  Application type 'ODX'
	//
	// Português:
	//
	//  Aplicação tipo 'ODX'
	KMimeApplicationODX Mime = "application/ODX"

	// KMimeApplicationOebpsPackageXml
	//
	// English:
	//
	//  Application type 'oebps-package+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'oebps-package+xml'
	KMimeApplicationOebpsPackageXml Mime = "application/oebps-package+xml"

	// KMimeApplicationOgg
	//
	// English:
	//
	//  Application type 'ogg'
	//
	// Português:
	//
	//  Aplicação tipo 'ogg'
	KMimeApplicationOgg Mime = "application/ogg"

	// KMimeApplicationOpcNodesetXml
	//
	// English:
	//
	//  Application type 'opc-nodeset+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'opc-nodeset+xml'
	KMimeApplicationOpcNodesetXml Mime = "application/opc-nodeset+xml"

	// KMimeApplicationOscore
	//
	// English:
	//
	//  Application type 'oscore'
	//
	// Português:
	//
	//  Aplicação tipo 'oscore'
	KMimeApplicationOscore Mime = "application/oscore"

	// KMimeApplicationOxps
	//
	// English:
	//
	//  Application type 'oxps'
	//
	// Português:
	//
	//  Aplicação tipo 'oxps'
	KMimeApplicationOxps Mime = "application/oxps"

	// KMimeApplicationP21
	//
	// English:
	//
	//  Application type 'p21'
	//
	// Português:
	//
	//  Aplicação tipo 'p21'
	KMimeApplicationP21 Mime = "application/p21"

	// KMimeApplicationP21Zip
	//
	// English:
	//
	//  Application type 'p21+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'p21+zip'
	KMimeApplicationP21Zip Mime = "application/p21+zip"

	// KMimeApplicationP2pOverlayXml
	//
	// English:
	//
	//  Application type 'p2p-overlay+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'p2p-overlay+xml'
	KMimeApplicationP2pOverlayXml Mime = "application/p2p-overlay+xml"

	// KMimeApplicationParityfec
	//
	// English:
	//
	//  Application type 'parityfec'
	//
	// Português:
	//
	//  Aplicação tipo 'parityfec'
	KMimeApplicationParityfec Mime = "application/parityfec"

	// KMimeApplicationPassport
	//
	// English:
	//
	//  Application type 'passport'
	//
	// Português:
	//
	//  Aplicação tipo 'passport'
	KMimeApplicationPassport Mime = "application/passport"

	// KMimeApplicationPatchOpsErrorXml
	//
	// English:
	//
	//  Application type 'patch-ops-error+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'patch-ops-error+xml'
	KMimeApplicationPatchOpsErrorXml Mime = "application/patch-ops-error+xml"

	// KMimeApplicationPdf
	//
	// English:
	//
	//  Application type 'pdf'
	//
	// Português:
	//
	//  Aplicação tipo 'pdf'
	KMimeApplicationPdf Mime = "application/pdf"

	// KMimeApplicationPDX
	//
	// English:
	//
	//  Application type 'PDX'
	//
	// Português:
	//
	//  Aplicação tipo 'PDX'
	KMimeApplicationPDX Mime = "application/PDX"

	// KMimeApplicationPemCertificateChain
	//
	// English:
	//
	//  Application type 'pem-certificate-chain'
	//
	// Português:
	//
	//  Aplicação tipo 'pem-certificate-chain'
	KMimeApplicationPemCertificateChain Mime = "application/pem-certificate-chain"

	// KMimeApplicationPgpEncrypted
	//
	// English:
	//
	//  Application type 'pgp-encrypted'
	//
	// Português:
	//
	//  Aplicação tipo 'pgp-encrypted'
	KMimeApplicationPgpEncrypted Mime = "application/pgp-encrypted"

	// KMimeApplicationPgpKeys
	//
	// English:
	//
	//  Application type 'pgp-keys'
	//
	// Português:
	//
	//  Aplicação tipo 'pgp-keys'
	KMimeApplicationPgpKeys Mime = "application/pgp-keys"

	// KMimeApplicationPgpSignature
	//
	// English:
	//
	//  Application type 'pgp-signature'
	//
	// Português:
	//
	//  Aplicação tipo 'pgp-signature'
	KMimeApplicationPgpSignature Mime = "application/pgp-signature"

	// KMimeApplicationPidfDiffXml
	//
	// English:
	//
	//  Application type 'pidf-diff+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'pidf-diff+xml'
	KMimeApplicationPidfDiffXml Mime = "application/pidf-diff+xml"

	// KMimeApplicationPidfXml
	//
	// English:
	//
	//  Application type 'pidf+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'pidf+xml'
	KMimeApplicationPidfXml Mime = "application/pidf+xml"

	// KMimeApplicationPkcs10
	//
	// English:
	//
	//  Application type 'pkcs10'
	//
	// Português:
	//
	//  Aplicação tipo 'pkcs10'
	KMimeApplicationPkcs10 Mime = "application/pkcs10"

	// KMimeApplicationPkcs7Mime
	//
	// English:
	//
	//  Application type 'pkcs7-mime'
	//
	// Português:
	//
	//  Aplicação tipo 'pkcs7-mime'
	KMimeApplicationPkcs7Mime Mime = "application/pkcs7-mime"

	// KMimeApplicationPkcs7Signature
	//
	// English:
	//
	//  Application type 'pkcs7-signature'
	//
	// Português:
	//
	//  Aplicação tipo 'pkcs7-signature'
	KMimeApplicationPkcs7Signature Mime = "application/pkcs7-signature"

	// KMimeApplicationPkcs8
	//
	// English:
	//
	//  Application type 'pkcs8'
	//
	// Português:
	//
	//  Aplicação tipo 'pkcs8'
	KMimeApplicationPkcs8 Mime = "application/pkcs8"

	// KMimeApplicationPkcs8Encrypted
	//
	// English:
	//
	//  Application type 'pkcs8-encrypted'
	//
	// Português:
	//
	//  Aplicação tipo 'pkcs8-encrypted'
	KMimeApplicationPkcs8Encrypted Mime = "application/pkcs8-encrypted"

	// KMimeApplicationPkcs12
	//
	// English:
	//
	//  Application type 'pkcs12'
	//
	// Português:
	//
	//  Aplicação tipo 'pkcs12'
	KMimeApplicationPkcs12 Mime = "application/pkcs12"

	// KMimeApplicationPkixAttrCert
	//
	// English:
	//
	//  Application type 'pkix-attr-cert'
	//
	// Português:
	//
	//  Aplicação tipo 'pkix-attr-cert'
	KMimeApplicationPkixAttrCert Mime = "application/pkix-attr-cert"

	// KMimeApplicationPkixCert
	//
	// English:
	//
	//  Application type 'pkix-cert'
	//
	// Português:
	//
	//  Aplicação tipo 'pkix-cert'
	KMimeApplicationPkixCert Mime = "application/pkix-cert"

	// KMimeApplicationPkixCrl
	//
	// English:
	//
	//  Application type 'pkix-crl'
	//
	// Português:
	//
	//  Aplicação tipo 'pkix-crl'
	KMimeApplicationPkixCrl Mime = "application/pkix-crl"

	// KMimeApplicationPkixPkipath
	//
	// English:
	//
	//  Application type 'pkix-pkipath'
	//
	// Português:
	//
	//  Aplicação tipo 'pkix-pkipath'
	KMimeApplicationPkixPkipath Mime = "application/pkix-pkipath"

	// KMimeApplicationPkixcmp
	//
	// English:
	//
	//  Application type 'pkixcmp'
	//
	// Português:
	//
	//  Aplicação tipo 'pkixcmp'
	KMimeApplicationPkixcmp Mime = "application/pkixcmp"

	// KMimeApplicationPlsXml
	//
	// English:
	//
	//  Application type 'pls+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'pls+xml'
	KMimeApplicationPlsXml Mime = "application/pls+xml"

	// KMimeApplicationPocSettingsXml
	//
	// English:
	//
	//  Application type 'poc-settings+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'poc-settings+xml'
	KMimeApplicationPocSettingsXml Mime = "application/poc-settings+xml"

	// KMimeApplicationPostscript
	//
	// English:
	//
	//  Application type 'postscript'
	//
	// Português:
	//
	//  Aplicação tipo 'postscript'
	KMimeApplicationPostscript Mime = "application/postscript"

	// KMimeApplicationPpspTrackerJson
	//
	// English:
	//
	//  Application type 'ppsp-tracker+json'
	//
	// Português:
	//
	//  Aplicação tipo 'ppsp-tracker+json'
	KMimeApplicationPpspTrackerJson Mime = "application/ppsp-tracker+json"

	// KMimeApplicationProblemJson
	//
	// English:
	//
	//  Application type 'problem+json'
	//
	// Português:
	//
	//  Aplicação tipo 'problem+json'
	KMimeApplicationProblemJson Mime = "application/problem+json"

	// KMimeApplicationProblemXml
	//
	// English:
	//
	//  Application type 'problem+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'problem+xml'
	KMimeApplicationProblemXml Mime = "application/problem+xml"

	// KMimeApplicationProvenanceXml
	//
	// English:
	//
	//  Application type 'provenance+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'provenance+xml'
	KMimeApplicationProvenanceXml Mime = "application/provenance+xml"

	// KMimeApplicationPrsAlvestrandTitraxSheet
	//
	// English:
	//
	//  Application type 'prs.alvestrand.titrax-sheet'
	//
	// Português:
	//
	//  Aplicação tipo 'prs.alvestrand.titrax-sheet'
	KMimeApplicationPrsAlvestrandTitraxSheet Mime = "application/prs.alvestrand.titrax-sheet"

	// KMimeApplicationPrsCww
	//
	// English:
	//
	//  Application type 'prs.cww'
	//
	// Português:
	//
	//  Aplicação tipo 'prs.cww'
	KMimeApplicationPrsCww Mime = "application/prs.cww"

	// KMimeApplicationPrsCyn
	//
	// English:
	//
	//  Application type 'prs.cyn'
	//
	// Português:
	//
	//  Aplicação tipo 'prs.cyn'
	KMimeApplicationPrsCyn Mime = "application/prs.cyn"

	// KMimeApplicationPrsHpubZip
	//
	// English:
	//
	//  Application type 'prs.hpub+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'prs.hpub+zip'
	KMimeApplicationPrsHpubZip Mime = "application/prs.hpub+zip"

	// KMimeApplicationPrsNprend
	//
	// English:
	//
	//  Application type 'prs.nprend'
	//
	// Português:
	//
	//  Aplicação tipo 'prs.nprend'
	KMimeApplicationPrsNprend Mime = "application/prs.nprend"

	// KMimeApplicationPrsPlucker
	//
	// English:
	//
	//  Application type 'prs.plucker'
	//
	// Português:
	//
	//  Aplicação tipo 'prs.plucker'
	KMimeApplicationPrsPlucker Mime = "application/prs.plucker"

	// KMimeApplicationPrsRdfXmlCrypt
	//
	// English:
	//
	//  Application type 'prs.rdf-xml-crypt'
	//
	// Português:
	//
	//  Aplicação tipo 'prs.rdf-xml-crypt'
	KMimeApplicationPrsRdfXmlCrypt Mime = "application/prs.rdf-xml-crypt"

	// KMimeApplicationPrsXsfXml
	//
	// English:
	//
	//  Application type 'prs.xsf+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'prs.xsf+xml'
	KMimeApplicationPrsXsfXml Mime = "application/prs.xsf+xml"

	// KMimeApplicationPskcXml
	//
	// English:
	//
	//  Application type 'pskc+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'pskc+xml'
	KMimeApplicationPskcXml Mime = "application/pskc+xml"

	// KMimeApplicationPvdJson
	//
	// English:
	//
	//  Application type 'pvd+json'
	//
	// Português:
	//
	//  Aplicação tipo 'pvd+json'
	KMimeApplicationPvdJson Mime = "application/pvd+json"

	// KMimeApplicationRdfXml
	//
	// English:
	//
	//  Application type 'rdf+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'rdf+xml'
	KMimeApplicationRdfXml Mime = "application/rdf+xml"

	// KMimeApplicationRouteApdXml
	//
	// English:
	//
	//  Application type 'route-apd+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'route-apd+xml'
	KMimeApplicationRouteApdXml Mime = "application/route-apd+xml"

	// KMimeApplicationRouteSTsidXml
	//
	// English:
	//
	//  Application type 'route-s-tsid+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'route-s-tsid+xml'
	KMimeApplicationRouteSTsidXml Mime = "application/route-s-tsid+xml"

	// KMimeApplicationRouteUsdXml
	//
	// English:
	//
	//  Application type 'route-usd+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'route-usd+xml'
	KMimeApplicationRouteUsdXml Mime = "application/route-usd+xml"

	// KMimeApplicationQSIG
	//
	// English:
	//
	//  Application type 'QSIG'
	//
	// Português:
	//
	//  Aplicação tipo 'QSIG'
	KMimeApplicationQSIG Mime = "application/QSIG"

	// KMimeApplicationRaptorfec
	//
	// English:
	//
	//  Application type 'raptorfec'
	//
	// Português:
	//
	//  Aplicação tipo 'raptorfec'
	KMimeApplicationRaptorfec Mime = "application/raptorfec"

	// KMimeApplicationRdapJson
	//
	// English:
	//
	//  Application type 'rdap+json'
	//
	// Português:
	//
	//  Aplicação tipo 'rdap+json'
	KMimeApplicationRdapJson Mime = "application/rdap+json"

	// KMimeApplicationReginfoXml
	//
	// English:
	//
	//  Application type 'reginfo+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'reginfo+xml'
	KMimeApplicationReginfoXml Mime = "application/reginfo+xml"

	// KMimeApplicationRelaxNgCompactSyntax
	//
	// English:
	//
	//  Application type 'relax-ng-compact-syntax'
	//
	// Português:
	//
	//  Aplicação tipo 'relax-ng-compact-syntax'
	KMimeApplicationRelaxNgCompactSyntax Mime = "application/relax-ng-compact-syntax"

	// KMimeApplicationRemotePrinting
	//
	// English:
	//
	//  Application type 'remote-printing'
	//
	// Português:
	//
	//  Aplicação tipo 'remote-printing'
	KMimeApplicationRemotePrinting Mime = "application/remote-printing"

	// KMimeApplicationReputonJson
	//
	// English:
	//
	//  Application type 'reputon+json'
	//
	// Português:
	//
	//  Aplicação tipo 'reputon+json'
	KMimeApplicationReputonJson Mime = "application/reputon+json"

	// KMimeApplicationResourceListsDiffXml
	//
	// English:
	//
	//  Application type 'resource-lists-diff+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'resource-lists-diff+xml'
	KMimeApplicationResourceListsDiffXml Mime = "application/resource-lists-diff+xml"

	// KMimeApplicationResourceListsXml
	//
	// English:
	//
	//  Application type 'resource-lists+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'resource-lists+xml'
	KMimeApplicationResourceListsXml Mime = "application/resource-lists+xml"

	// KMimeApplicationRfcXml
	//
	// English:
	//
	//  Application type 'rfc+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'rfc+xml'
	KMimeApplicationRfcXml Mime = "application/rfc+xml"

	// KMimeApplicationRiscos
	//
	// English:
	//
	//  Application type 'riscos'
	//
	// Português:
	//
	//  Aplicação tipo 'riscos'
	KMimeApplicationRiscos Mime = "application/riscos"

	// KMimeApplicationRlmiXml
	//
	// English:
	//
	//  Application type 'rlmi+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'rlmi+xml'
	KMimeApplicationRlmiXml Mime = "application/rlmi+xml"

	// KMimeApplicationRlsServicesXml
	//
	// English:
	//
	//  Application type 'rls-services+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'rls-services+xml'
	KMimeApplicationRlsServicesXml Mime = "application/rls-services+xml"

	// KMimeApplicationRpkiGhostbusters
	//
	// English:
	//
	//  Application type 'rpki-ghostbusters'
	//
	// Português:
	//
	//  Aplicação tipo 'rpki-ghostbusters'
	KMimeApplicationRpkiGhostbusters Mime = "application/rpki-ghostbusters"

	// KMimeApplicationRpkiManifest
	//
	// English:
	//
	//  Application type 'rpki-manifest'
	//
	// Português:
	//
	//  Aplicação tipo 'rpki-manifest'
	KMimeApplicationRpkiManifest Mime = "application/rpki-manifest"

	// KMimeApplicationRpkiPublication
	//
	// English:
	//
	//  Application type 'rpki-publication'
	//
	// Português:
	//
	//  Aplicação tipo 'rpki-publication'
	KMimeApplicationRpkiPublication Mime = "application/rpki-publication"

	// KMimeApplicationRpkiRoa
	//
	// English:
	//
	//  Application type 'rpki-roa'
	//
	// Português:
	//
	//  Aplicação tipo 'rpki-roa'
	KMimeApplicationRpkiRoa Mime = "application/rpki-roa"

	// KMimeApplicationRpkiUpdown
	//
	// English:
	//
	//  Application type 'rpki-updown'
	//
	// Português:
	//
	//  Aplicação tipo 'rpki-updown'
	KMimeApplicationRpkiUpdown Mime = "application/rpki-updown"

	// KMimeApplicationRtf
	//
	// English:
	//
	//  Application type 'rtf'
	//
	// Português:
	//
	//  Aplicação tipo 'rtf'
	KMimeApplicationRtf Mime = "application/rtf"

	// KMimeApplicationRtploopback
	//
	// English:
	//
	//  Application type 'rtploopback'
	//
	// Português:
	//
	//  Aplicação tipo 'rtploopback'
	KMimeApplicationRtploopback Mime = "application/rtploopback"

	// KMimeApplicationRtx
	//
	// English:
	//
	//  Application type 'rtx'
	//
	// Português:
	//
	//  Aplicação tipo 'rtx'
	KMimeApplicationRtx Mime = "application/rtx"

	// KMimeApplicationSamlassertionXml
	//
	// English:
	//
	//  Application type 'samlassertion+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'samlassertion+xml'
	KMimeApplicationSamlassertionXml Mime = "application/samlassertion+xml"

	// KMimeApplicationSamlmetadataXml
	//
	// English:
	//
	//  Application type 'samlmetadata+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'samlmetadata+xml'
	KMimeApplicationSamlmetadataXml Mime = "application/samlmetadata+xml"

	// KMimeApplicationSarifExternalPropertiesJson
	//
	// English:
	//
	//  Application type 'sarif-external-properties+json'
	//
	// Português:
	//
	//  Aplicação tipo 'sarif-external-properties+json'
	KMimeApplicationSarifExternalPropertiesJson Mime = "application/sarif-external-properties+json"

	// KMimeApplicationSarifJson
	//
	// English:
	//
	//  Application type 'sarif+json'
	//
	// Português:
	//
	//  Aplicação tipo 'sarif+json'
	KMimeApplicationSarifJson Mime = "application/sarif+json"

	// KMimeApplicationSbe
	//
	// English:
	//
	//  Application type 'sbe'
	//
	// Português:
	//
	//  Aplicação tipo 'sbe'
	KMimeApplicationSbe Mime = "application/sbe"

	// KMimeApplicationSbmlXml
	//
	// English:
	//
	//  Application type 'sbml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'sbml+xml'
	KMimeApplicationSbmlXml Mime = "application/sbml+xml"

	// KMimeApplicationScaipXml
	//
	// English:
	//
	//  Application type 'scaip+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'scaip+xml'
	KMimeApplicationScaipXml Mime = "application/scaip+xml"

	// KMimeApplicationScimJson
	//
	// English:
	//
	//  Application type 'scim+json'
	//
	// Português:
	//
	//  Aplicação tipo 'scim+json'
	KMimeApplicationScimJson Mime = "application/scim+json"

	// KMimeApplicationScvpCvRequest
	//
	// English:
	//
	//  Application type 'scvp-cv-request'
	//
	// Português:
	//
	//  Aplicação tipo 'scvp-cv-request'
	KMimeApplicationScvpCvRequest Mime = "application/scvp-cv-request"

	// KMimeApplicationScvpCvResponse
	//
	// English:
	//
	//  Application type 'scvp-cv-response'
	//
	// Português:
	//
	//  Aplicação tipo 'scvp-cv-response'
	KMimeApplicationScvpCvResponse Mime = "application/scvp-cv-response"

	// KMimeApplicationScvpVpRequest
	//
	// English:
	//
	//  Application type 'scvp-vp-request'
	//
	// Português:
	//
	//  Aplicação tipo 'scvp-vp-request'
	KMimeApplicationScvpVpRequest Mime = "application/scvp-vp-request"

	// KMimeApplicationScvpVpResponse
	//
	// English:
	//
	//  Application type 'scvp-vp-response'
	//
	// Português:
	//
	//  Aplicação tipo 'scvp-vp-response'
	KMimeApplicationScvpVpResponse Mime = "application/scvp-vp-response"

	// KMimeApplicationSdp
	//
	// English:
	//
	//  Application type 'sdp'
	//
	// Português:
	//
	//  Aplicação tipo 'sdp'
	KMimeApplicationSdp Mime = "application/sdp"

	// KMimeApplicationSeceventJwt
	//
	// English:
	//
	//  Application type 'secevent+jwt'
	//
	// Português:
	//
	//  Aplicação tipo 'secevent+jwt'
	KMimeApplicationSeceventJwt Mime = "application/secevent+jwt"

	// KMimeApplicationSenmlEtchCbor
	//
	// English:
	//
	//  Application type 'senml-etch+cbor'
	//
	// Português:
	//
	//  Aplicação tipo 'senml-etch+cbor'
	KMimeApplicationSenmlEtchCbor Mime = "application/senml-etch+cbor"

	// KMimeApplicationSenmlEtchJson
	//
	// English:
	//
	//  Application type 'senml-etch+json'
	//
	// Português:
	//
	//  Aplicação tipo 'senml-etch+json'
	KMimeApplicationSenmlEtchJson Mime = "application/senml-etch+json"

	// KMimeApplicationSenmlExi
	//
	// English:
	//
	//  Application type 'senml-exi'
	//
	// Português:
	//
	//  Aplicação tipo 'senml-exi'
	KMimeApplicationSenmlExi Mime = "application/senml-exi"

	// KMimeApplicationSenmlCbor
	//
	// English:
	//
	//  Application type 'senml+cbor'
	//
	// Português:
	//
	//  Aplicação tipo 'senml+cbor'
	KMimeApplicationSenmlCbor Mime = "application/senml+cbor"

	// KMimeApplicationSenmlJson
	//
	// English:
	//
	//  Application type 'senml+json'
	//
	// Português:
	//
	//  Aplicação tipo 'senml+json'
	KMimeApplicationSenmlJson Mime = "application/senml+json"

	// KMimeApplicationSenmlXml
	//
	// English:
	//
	//  Application type 'senml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'senml+xml'
	KMimeApplicationSenmlXml Mime = "application/senml+xml"

	// KMimeApplicationSensmlExi
	//
	// English:
	//
	//  Application type 'sensml-exi'
	//
	// Português:
	//
	//  Aplicação tipo 'sensml-exi'
	KMimeApplicationSensmlExi Mime = "application/sensml-exi"

	// KMimeApplicationSensmlCbor
	//
	// English:
	//
	//  Application type 'sensml+cbor'
	//
	// Português:
	//
	//  Aplicação tipo 'sensml+cbor'
	KMimeApplicationSensmlCbor Mime = "application/sensml+cbor"

	// KMimeApplicationSensmlJson
	//
	// English:
	//
	//  Application type 'sensml+json'
	//
	// Português:
	//
	//  Aplicação tipo 'sensml+json'
	KMimeApplicationSensmlJson Mime = "application/sensml+json"

	// KMimeApplicationSensmlXml
	//
	// English:
	//
	//  Application type 'sensml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'sensml+xml'
	KMimeApplicationSensmlXml Mime = "application/sensml+xml"

	// KMimeApplicationSepExi
	//
	// English:
	//
	//  Application type 'sep-exi'
	//
	// Português:
	//
	//  Aplicação tipo 'sep-exi'
	KMimeApplicationSepExi Mime = "application/sep-exi"

	// KMimeApplicationSepXml
	//
	// English:
	//
	//  Application type 'sep+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'sep+xml'
	KMimeApplicationSepXml Mime = "application/sep+xml"

	// KMimeApplicationSessionInfo
	//
	// English:
	//
	//  Application type 'session-info'
	//
	// Português:
	//
	//  Aplicação tipo 'session-info'
	KMimeApplicationSessionInfo Mime = "application/session-info"

	// KMimeApplicationSetPayment
	//
	// English:
	//
	//  Application type 'set-payment'
	//
	// Português:
	//
	//  Aplicação tipo 'set-payment'
	KMimeApplicationSetPayment Mime = "application/set-payment"

	// KMimeApplicationSetPaymentInitiation
	//
	// English:
	//
	//  Application type 'set-payment-initiation'
	//
	// Português:
	//
	//  Aplicação tipo 'set-payment-initiation'
	KMimeApplicationSetPaymentInitiation Mime = "application/set-payment-initiation"

	// KMimeApplicationSetRegistration
	//
	// English:
	//
	//  Application type 'set-registration'
	//
	// Português:
	//
	//  Aplicação tipo 'set-registration'
	KMimeApplicationSetRegistration Mime = "application/set-registration"

	// KMimeApplicationSetRegistrationInitiation
	//
	// English:
	//
	//  Application type 'set-registration-initiation'
	//
	// Português:
	//
	//  Aplicação tipo 'set-registration-initiation'
	KMimeApplicationSetRegistrationInitiation Mime = "application/set-registration-initiation"

	// KMimeApplicationSGML
	//
	// English:
	//
	//  Application type 'SGML'
	//
	// Português:
	//
	//  Aplicação tipo 'SGML'
	KMimeApplicationSGML Mime = "application/SGML"

	// KMimeApplicationSgmlOpenCatalog
	//
	// English:
	//
	//  Application type 'sgml-open-catalog'
	//
	// Português:
	//
	//  Aplicação tipo 'sgml-open-catalog'
	KMimeApplicationSgmlOpenCatalog Mime = "application/sgml-open-catalog"

	// KMimeApplicationShfXml
	//
	// English:
	//
	//  Application type 'shf+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'shf+xml'
	KMimeApplicationShfXml Mime = "application/shf+xml"

	// KMimeApplicationSieve
	//
	// English:
	//
	//  Application type 'sieve'
	//
	// Português:
	//
	//  Aplicação tipo 'sieve'
	KMimeApplicationSieve Mime = "application/sieve"

	// KMimeApplicationSimpleFilterXml
	//
	// English:
	//
	//  Application type 'simple-filter+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'simple-filter+xml'
	KMimeApplicationSimpleFilterXml Mime = "application/simple-filter+xml"

	// KMimeApplicationSimpleMessageSummary
	//
	// English:
	//
	//  Application type 'simple-message-summary'
	//
	// Português:
	//
	//  Aplicação tipo 'simple-message-summary'
	KMimeApplicationSimpleMessageSummary Mime = "application/simple-message-summary"

	// KMimeApplicationSimpleSymbolContainer
	//
	// English:
	//
	//  Application type 'simpleSymbolContainer'
	//
	// Português:
	//
	//  Aplicação tipo 'simpleSymbolContainer'
	KMimeApplicationSimpleSymbolContainer Mime = "application/simpleSymbolContainer"

	// KMimeApplicationSipc
	//
	// English:
	//
	//  Application type 'sipc'
	//
	// Português:
	//
	//  Aplicação tipo 'sipc'
	KMimeApplicationSipc Mime = "application/sipc"

	// KMimeApplicationSlate
	//
	// English:
	//
	//  Application type 'slate'
	//
	// Português:
	//
	//  Aplicação tipo 'slate'
	KMimeApplicationSlate Mime = "application/slate"

	// KMimeApplicationSmil
	//
	// English:
	//
	//  Application type 'smil'
	//
	// Português:
	//
	//  Aplicação tipo 'smil'
	KMimeApplicationSmil Mime = "(OBSOLETED"

	// KMimeApplicationSmilXml
	//
	// English:
	//
	//  Application type 'smil+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'smil+xml'
	KMimeApplicationSmilXml Mime = "application/smil+xml"

	// KMimeApplicationSmpte336m
	//
	// English:
	//
	//  Application type 'smpte336m'
	//
	// Português:
	//
	//  Aplicação tipo 'smpte336m'
	KMimeApplicationSmpte336m Mime = "application/smpte336m"

	// KMimeApplicationSoapFastinfoset
	//
	// English:
	//
	//  Application type 'soap+fastinfoset'
	//
	// Português:
	//
	//  Aplicação tipo 'soap+fastinfoset'
	KMimeApplicationSoapFastinfoset Mime = "application/soap+fastinfoset"

	// KMimeApplicationSoapXml
	//
	// English:
	//
	//  Application type 'soap+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'soap+xml'
	KMimeApplicationSoapXml Mime = "application/soap+xml"

	// KMimeApplicationSparqlQuery
	//
	// English:
	//
	//  Application type 'sparql-query'
	//
	// Português:
	//
	//  Aplicação tipo 'sparql-query'
	KMimeApplicationSparqlQuery Mime = "application/sparql-query"

	// KMimeApplicationSpdxJson
	//
	// English:
	//
	//  Application type 'spdx+json'
	//
	// Português:
	//
	//  Aplicação tipo 'spdx+json'
	KMimeApplicationSpdxJson Mime = "application/spdx+json"

	// KMimeApplicationSparqlResultsXml
	//
	// English:
	//
	//  Application type 'sparql-results+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'sparql-results+xml'
	KMimeApplicationSparqlResultsXml Mime = "application/sparql-results+xml"

	// KMimeApplicationSpiritsEventXml
	//
	// English:
	//
	//  Application type 'spirits-event+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'spirits-event+xml'
	KMimeApplicationSpiritsEventXml Mime = "application/spirits-event+xml"

	// KMimeApplicationSql
	//
	// English:
	//
	//  Application type 'sql'
	//
	// Português:
	//
	//  Aplicação tipo 'sql'
	KMimeApplicationSql Mime = "application/sql"

	// KMimeApplicationSrgs
	//
	// English:
	//
	//  Application type 'srgs'
	//
	// Português:
	//
	//  Aplicação tipo 'srgs'
	KMimeApplicationSrgs Mime = "application/srgs"

	// KMimeApplicationSrgsXml
	//
	// English:
	//
	//  Application type 'srgs+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'srgs+xml'
	KMimeApplicationSrgsXml Mime = "application/srgs+xml"

	// KMimeApplicationSruXml
	//
	// English:
	//
	//  Application type 'sru+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'sru+xml'
	KMimeApplicationSruXml Mime = "application/sru+xml"

	// KMimeApplicationSsmlXml
	//
	// English:
	//
	//  Application type 'ssml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'ssml+xml'
	KMimeApplicationSsmlXml Mime = "application/ssml+xml"

	// KMimeApplicationStixJson
	//
	// English:
	//
	//  Application type 'stix+json'
	//
	// Português:
	//
	//  Aplicação tipo 'stix+json'
	KMimeApplicationStixJson Mime = "application/stix+json"

	// KMimeApplicationSwidXml
	//
	// English:
	//
	//  Application type 'swid+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'swid+xml'
	KMimeApplicationSwidXml Mime = "application/swid+xml"

	// KMimeApplicationTampApexUpdate
	//
	// English:
	//
	//  Application type 'tamp-apex-update'
	//
	// Português:
	//
	//  Aplicação tipo 'tamp-apex-update'
	KMimeApplicationTampApexUpdate Mime = "application/tamp-apex-update"

	// KMimeApplicationTampApexUpdateConfirm
	//
	// English:
	//
	//  Application type 'tamp-apex-update-confirm'
	//
	// Português:
	//
	//  Aplicação tipo 'tamp-apex-update-confirm'
	KMimeApplicationTampApexUpdateConfirm Mime = "application/tamp-apex-update-confirm"

	// KMimeApplicationTampCommunityUpdate
	//
	// English:
	//
	//  Application type 'tamp-community-update'
	//
	// Português:
	//
	//  Aplicação tipo 'tamp-community-update'
	KMimeApplicationTampCommunityUpdate Mime = "application/tamp-community-update"

	// KMimeApplicationTampCommunityUpdateConfirm
	//
	// English:
	//
	//  Application type 'tamp-community-update-confirm'
	//
	// Português:
	//
	//  Aplicação tipo 'tamp-community-update-confirm'
	KMimeApplicationTampCommunityUpdateConfirm Mime = "application/tamp-community-update-confirm"

	// KMimeApplicationTampError
	//
	// English:
	//
	//  Application type 'tamp-error'
	//
	// Português:
	//
	//  Aplicação tipo 'tamp-error'
	KMimeApplicationTampError Mime = "application/tamp-error"

	// KMimeApplicationTampSequenceAdjust
	//
	// English:
	//
	//  Application type 'tamp-sequence-adjust'
	//
	// Português:
	//
	//  Aplicação tipo 'tamp-sequence-adjust'
	KMimeApplicationTampSequenceAdjust Mime = "application/tamp-sequence-adjust"

	// KMimeApplicationTampSequenceAdjustConfirm
	//
	// English:
	//
	//  Application type 'tamp-sequence-adjust-confirm'
	//
	// Português:
	//
	//  Aplicação tipo 'tamp-sequence-adjust-confirm'
	KMimeApplicationTampSequenceAdjustConfirm Mime = "application/tamp-sequence-adjust-confirm"

	// KMimeApplicationTampStatusQuery
	//
	// English:
	//
	//  Application type 'tamp-status-query'
	//
	// Português:
	//
	//  Aplicação tipo 'tamp-status-query'
	KMimeApplicationTampStatusQuery Mime = "application/tamp-status-query"

	// KMimeApplicationTampStatusResponse
	//
	// English:
	//
	//  Application type 'tamp-status-response'
	//
	// Português:
	//
	//  Aplicação tipo 'tamp-status-response'
	KMimeApplicationTampStatusResponse Mime = "application/tamp-status-response"

	// KMimeApplicationTampUpdate
	//
	// English:
	//
	//  Application type 'tamp-update'
	//
	// Português:
	//
	//  Aplicação tipo 'tamp-update'
	KMimeApplicationTampUpdate Mime = "application/tamp-update"

	// KMimeApplicationTampUpdateConfirm
	//
	// English:
	//
	//  Application type 'tamp-update-confirm'
	//
	// Português:
	//
	//  Aplicação tipo 'tamp-update-confirm'
	KMimeApplicationTampUpdateConfirm Mime = "application/tamp-update-confirm"

	// KMimeApplicationTaxiiJson
	//
	// English:
	//
	//  Application type 'taxii+json'
	//
	// Português:
	//
	//  Aplicação tipo 'taxii+json'
	KMimeApplicationTaxiiJson Mime = "application/taxii+json"

	// KMimeApplicationTdJson
	//
	// English:
	//
	//  Application type 'td+json'
	//
	// Português:
	//
	//  Aplicação tipo 'td+json'
	KMimeApplicationTdJson Mime = "application/td+json"

	// KMimeApplicationTeiXml
	//
	// English:
	//
	//  Application type 'tei+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'tei+xml'
	KMimeApplicationTeiXml Mime = "application/tei+xml"

	// KMimeApplicationTETRAISI
	//
	// English:
	//
	//  Application type 'TETRA_ISI'
	//
	// Português:
	//
	//  Aplicação tipo 'TETRA_ISI'
	KMimeApplicationTETRAISI Mime = "application/TETRA_ISI"

	// KMimeApplicationThraudXml
	//
	// English:
	//
	//  Application type 'thraud+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'thraud+xml'
	KMimeApplicationThraudXml Mime = "application/thraud+xml"

	// KMimeApplicationTimestampQuery
	//
	// English:
	//
	//  Application type 'timestamp-query'
	//
	// Português:
	//
	//  Aplicação tipo 'timestamp-query'
	KMimeApplicationTimestampQuery Mime = "application/timestamp-query"

	// KMimeApplicationTimestampReply
	//
	// English:
	//
	//  Application type 'timestamp-reply'
	//
	// Português:
	//
	//  Aplicação tipo 'timestamp-reply'
	KMimeApplicationTimestampReply Mime = "application/timestamp-reply"

	// KMimeApplicationTimestampedData
	//
	// English:
	//
	//  Application type 'timestamped-data'
	//
	// Português:
	//
	//  Aplicação tipo 'timestamped-data'
	KMimeApplicationTimestampedData Mime = "application/timestamped-data"

	// KMimeApplicationTlsrptGzip
	//
	// English:
	//
	//  Application type 'tlsrpt+gzip'
	//
	// Português:
	//
	//  Aplicação tipo 'tlsrpt+gzip'
	KMimeApplicationTlsrptGzip Mime = "application/tlsrpt+gzip"

	// KMimeApplicationTlsrptJson
	//
	// English:
	//
	//  Application type 'tlsrpt+json'
	//
	// Português:
	//
	//  Aplicação tipo 'tlsrpt+json'
	KMimeApplicationTlsrptJson Mime = "application/tlsrpt+json"

	// KMimeApplicationTnauthlist
	//
	// English:
	//
	//  Application type 'tnauthlist'
	//
	// Português:
	//
	//  Aplicação tipo 'tnauthlist'
	KMimeApplicationTnauthlist Mime = "application/tnauthlist"

	// KMimeApplicationTokenIntrospectionJwt
	//
	// English:
	//
	//  Application type 'token-introspection+jwt'
	//
	// Português:
	//
	//  Aplicação tipo 'token-introspection+jwt'
	KMimeApplicationTokenIntrospectionJwt Mime = "application/token-introspection+jwt"

	// KMimeApplicationTrickleIceSdpfrag
	//
	// English:
	//
	//  Application type 'trickle-ice-sdpfrag'
	//
	// Português:
	//
	//  Aplicação tipo 'trickle-ice-sdpfrag'
	KMimeApplicationTrickleIceSdpfrag Mime = "application/trickle-ice-sdpfrag"

	// KMimeApplicationTrig
	//
	// English:
	//
	//  Application type 'trig'
	//
	// Português:
	//
	//  Aplicação tipo 'trig'
	KMimeApplicationTrig Mime = "application/trig"

	// KMimeApplicationTtmlXml
	//
	// English:
	//
	//  Application type 'ttml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'ttml+xml'
	KMimeApplicationTtmlXml Mime = "application/ttml+xml"

	// KMimeApplicationTveTrigger
	//
	// English:
	//
	//  Application type 'tve-trigger'
	//
	// Português:
	//
	//  Aplicação tipo 'tve-trigger'
	KMimeApplicationTveTrigger Mime = "application/tve-trigger"

	// KMimeApplicationTzif
	//
	// English:
	//
	//  Application type 'tzif'
	//
	// Português:
	//
	//  Aplicação tipo 'tzif'
	KMimeApplicationTzif Mime = "application/tzif"

	// KMimeApplicationTzifLeap
	//
	// English:
	//
	//  Application type 'tzif-leap'
	//
	// Português:
	//
	//  Aplicação tipo 'tzif-leap'
	KMimeApplicationTzifLeap Mime = "application/tzif-leap"

	// KMimeApplicationUlpfec
	//
	// English:
	//
	//  Application type 'ulpfec'
	//
	// Português:
	//
	//  Aplicação tipo 'ulpfec'
	KMimeApplicationUlpfec Mime = "application/ulpfec"

	// KMimeApplicationUrcGrpsheetXml
	//
	// English:
	//
	//  Application type 'urc-grpsheet+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'urc-grpsheet+xml'
	KMimeApplicationUrcGrpsheetXml Mime = "application/urc-grpsheet+xml"

	// KMimeApplicationUrcRessheetXml
	//
	// English:
	//
	//  Application type 'urc-ressheet+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'urc-ressheet+xml'
	KMimeApplicationUrcRessheetXml Mime = "application/urc-ressheet+xml"

	// KMimeApplicationUrcTargetdescXml
	//
	// English:
	//
	//  Application type 'urc-targetdesc+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'urc-targetdesc+xml'
	KMimeApplicationUrcTargetdescXml Mime = "application/urc-targetdesc+xml"

	// KMimeApplicationUrcUisocketdescXml
	//
	// English:
	//
	//  Application type 'urc-uisocketdesc+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'urc-uisocketdesc+xml'
	KMimeApplicationUrcUisocketdescXml Mime = "application/urc-uisocketdesc+xml"

	// KMimeApplicationVcardJson
	//
	// English:
	//
	//  Application type 'vcard+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vcard+json'
	KMimeApplicationVcardJson Mime = "application/vcard+json"

	// KMimeApplicationVcardXml
	//
	// English:
	//
	//  Application type 'vcard+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vcard+xml'
	KMimeApplicationVcardXml Mime = "application/vcard+xml"

	// KMimeApplicationVemmi
	//
	// English:
	//
	//  Application type 'vemmi'
	//
	// Português:
	//
	//  Aplicação tipo 'vemmi'
	KMimeApplicationVemmi Mime = "application/vemmi"

	// KMimeApplicationVnd1000mindsDecisionModelXml
	//
	// English:
	//
	//  Application type 'vnd.1000minds.decision-model+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.1000minds.decision-model+xml'
	KMimeApplicationVnd1000mindsDecisionModelXml Mime = "application/vnd.1000minds.decision-model+xml"

	// KMimeApplicationVnd3gpp5gnas
	//
	// English:
	//
	//  Application type 'vnd.3gpp.5gnas'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.5gnas'
	KMimeApplicationVnd3gpp5gnas Mime = "application/vnd.3gpp.5gnas"

	// KMimeApplicationVnd3gppAccessTransferEventsXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.access-transfer-events+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.access-transfer-events+xml'
	KMimeApplicationVnd3gppAccessTransferEventsXml Mime = "application/vnd.3gpp.access-transfer-events+xml"

	// KMimeApplicationVnd3gppBsfXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.bsf+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.bsf+xml'
	KMimeApplicationVnd3gppBsfXml Mime = "application/vnd.3gpp.bsf+xml"

	// KMimeApplicationVnd3gppGMOPXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.GMOP+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.GMOP+xml'
	KMimeApplicationVnd3gppGMOPXml Mime = "application/vnd.3gpp.GMOP+xml"

	// KMimeApplicationVnd3gppGtpc
	//
	// English:
	//
	//  Application type 'vnd.3gpp.gtpc'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.gtpc'
	KMimeApplicationVnd3gppGtpc Mime = "application/vnd.3gpp.gtpc"

	// KMimeApplicationVnd3gppInterworkingData
	//
	// English:
	//
	//  Application type 'vnd.3gpp.interworking-data'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.interworking-data'
	KMimeApplicationVnd3gppInterworkingData Mime = "application/vnd.3gpp.interworking-data"

	// KMimeApplicationVnd3gppLpp
	//
	// English:
	//
	//  Application type 'vnd.3gpp.lpp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.lpp'
	KMimeApplicationVnd3gppLpp Mime = "application/vnd.3gpp.lpp"

	// KMimeApplicationVnd3gppMcSignallingEar
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mc-signalling-ear'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mc-signalling-ear'
	KMimeApplicationVnd3gppMcSignallingEar Mime = "application/vnd.3gpp.mc-signalling-ear"

	// KMimeApplicationVnd3gppMcdataAffiliationCommandXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcdata-affiliation-command+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcdata-affiliation-command+xml'
	KMimeApplicationVnd3gppMcdataAffiliationCommandXml Mime = "application/vnd.3gpp.mcdata-affiliation-command+xml"

	// KMimeApplicationVnd3gppMcdataInfoXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcdata-info+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcdata-info+xml'
	KMimeApplicationVnd3gppMcdataInfoXml Mime = "application/vnd.3gpp.mcdata-info+xml"

	// KMimeApplicationVnd3gppMcdataMsgstoreCtrlRequestXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcdata-msgstore-ctrl-request+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcdata-msgstore-ctrl-request+xml'
	KMimeApplicationVnd3gppMcdataMsgstoreCtrlRequestXml Mime = "application/vnd.3gpp.mcdata-msgstore-ctrl-request+xml"

	// KMimeApplicationVnd3gppMcdataPayload
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcdata-payload'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcdata-payload'
	KMimeApplicationVnd3gppMcdataPayload Mime = "application/vnd.3gpp.mcdata-payload"

	// KMimeApplicationVnd3gppMcdataRegroupXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcdata-regroup+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcdata-regroup+xml'
	KMimeApplicationVnd3gppMcdataRegroupXml Mime = "application/vnd.3gpp.mcdata-regroup+xml"

	// KMimeApplicationVnd3gppMcdataServiceConfigXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcdata-service-config+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcdata-service-config+xml'
	KMimeApplicationVnd3gppMcdataServiceConfigXml Mime = "application/vnd.3gpp.mcdata-service-config+xml"

	// KMimeApplicationVnd3gppMcdataSignalling
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcdata-signalling'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcdata-signalling'
	KMimeApplicationVnd3gppMcdataSignalling Mime = "application/vnd.3gpp.mcdata-signalling"

	// KMimeApplicationVnd3gppMcdataUeConfigXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcdata-ue-config+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcdata-ue-config+xml'
	KMimeApplicationVnd3gppMcdataUeConfigXml Mime = "application/vnd.3gpp.mcdata-ue-config+xml"

	// KMimeApplicationVnd3gppMcdataUserProfileXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcdata-user-profile+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcdata-user-profile+xml'
	KMimeApplicationVnd3gppMcdataUserProfileXml Mime = "application/vnd.3gpp.mcdata-user-profile+xml"

	// KMimeApplicationVnd3gppMcpttAffiliationCommandXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcptt-affiliation-command+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcptt-affiliation-command+xml'
	KMimeApplicationVnd3gppMcpttAffiliationCommandXml Mime = "application/vnd.3gpp.mcptt-affiliation-command+xml"

	// KMimeApplicationVnd3gppMcpttFloorRequestXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcptt-floor-request+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcptt-floor-request+xml'
	KMimeApplicationVnd3gppMcpttFloorRequestXml Mime = "application/vnd.3gpp.mcptt-floor-request+xml"

	// KMimeApplicationVnd3gppMcpttInfoXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcptt-info+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcptt-info+xml'
	KMimeApplicationVnd3gppMcpttInfoXml Mime = "application/vnd.3gpp.mcptt-info+xml"

	// KMimeApplicationVnd3gppMcpttLocationInfoXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcptt-location-info+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcptt-location-info+xml'
	KMimeApplicationVnd3gppMcpttLocationInfoXml Mime = "application/vnd.3gpp.mcptt-location-info+xml"

	// KMimeApplicationVnd3gppMcpttMbmsUsageInfoXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcptt-mbms-usage-info+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcptt-mbms-usage-info+xml'
	KMimeApplicationVnd3gppMcpttMbmsUsageInfoXml Mime = "application/vnd.3gpp.mcptt-mbms-usage-info+xml"

	// KMimeApplicationVnd3gppMcpttServiceConfigXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcptt-service-config+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcptt-service-config+xml'
	KMimeApplicationVnd3gppMcpttServiceConfigXml Mime = "application/vnd.3gpp.mcptt-service-config+xml"

	// KMimeApplicationVnd3gppMcpttSignedXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcptt-signed+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcptt-signed+xml'
	KMimeApplicationVnd3gppMcpttSignedXml Mime = "application/vnd.3gpp.mcptt-signed+xml"

	// KMimeApplicationVnd3gppMcpttUeConfigXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcptt-ue-config+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcptt-ue-config+xml'
	KMimeApplicationVnd3gppMcpttUeConfigXml Mime = "application/vnd.3gpp.mcptt-ue-config+xml"

	// KMimeApplicationVnd3gppMcpttUeInitConfigXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcptt-ue-init-config+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcptt-ue-init-config+xml'
	KMimeApplicationVnd3gppMcpttUeInitConfigXml Mime = "application/vnd.3gpp.mcptt-ue-init-config+xml"

	// KMimeApplicationVnd3gppMcpttUserProfileXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcptt-user-profile+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcptt-user-profile+xml'
	KMimeApplicationVnd3gppMcpttUserProfileXml Mime = "application/vnd.3gpp.mcptt-user-profile+xml"

	// KMimeApplicationVnd3gppMcvideoAffiliationCommandXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcvideo-affiliation-command+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcvideo-affiliation-command+xml'
	KMimeApplicationVnd3gppMcvideoAffiliationCommandXml Mime = "application/vnd.3gpp.mcvideo-affiliation-command+xml"

	// KMimeApplicationVnd3gppMcvideoAffiliationInfoXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcvideo-affiliation-info+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcvideo-affiliation-info+xml'
	KMimeApplicationVnd3gppMcvideoAffiliationInfoXml Mime = "(OBSOLETED"

	// KMimeApplicationVnd3gppMcvideoInfoXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcvideo-info+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcvideo-info+xml'
	KMimeApplicationVnd3gppMcvideoInfoXml Mime = "application/vnd.3gpp.mcvideo-info+xml"

	// KMimeApplicationVnd3gppMcvideoLocationInfoXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcvideo-location-info+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcvideo-location-info+xml'
	KMimeApplicationVnd3gppMcvideoLocationInfoXml Mime = "application/vnd.3gpp.mcvideo-location-info+xml"

	// KMimeApplicationVnd3gppMcvideoMbmsUsageInfoXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcvideo-mbms-usage-info+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcvideo-mbms-usage-info+xml'
	KMimeApplicationVnd3gppMcvideoMbmsUsageInfoXml Mime = "application/vnd.3gpp.mcvideo-mbms-usage-info+xml"

	// KMimeApplicationVnd3gppMcvideoServiceConfigXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcvideo-service-config+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcvideo-service-config+xml'
	KMimeApplicationVnd3gppMcvideoServiceConfigXml Mime = "application/vnd.3gpp.mcvideo-service-config+xml"

	// KMimeApplicationVnd3gppMcvideoTransmissionRequestXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcvideo-transmission-request+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcvideo-transmission-request+xml'
	KMimeApplicationVnd3gppMcvideoTransmissionRequestXml Mime = "application/vnd.3gpp.mcvideo-transmission-request+xml"

	// KMimeApplicationVnd3gppMcvideoUeConfigXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcvideo-ue-config+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcvideo-ue-config+xml'
	KMimeApplicationVnd3gppMcvideoUeConfigXml Mime = "application/vnd.3gpp.mcvideo-ue-config+xml"

	// KMimeApplicationVnd3gppMcvideoUserProfileXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcvideo-user-profile+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcvideo-user-profile+xml'
	KMimeApplicationVnd3gppMcvideoUserProfileXml Mime = "application/vnd.3gpp.mcvideo-user-profile+xml"

	// KMimeApplicationVnd3gppMidCallXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mid-call+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mid-call+xml'
	KMimeApplicationVnd3gppMidCallXml Mime = "application/vnd.3gpp.mid-call+xml"

	// KMimeApplicationVnd3gppNgap
	//
	// English:
	//
	//  Application type 'vnd.3gpp.ngap'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.ngap'
	KMimeApplicationVnd3gppNgap Mime = "application/vnd.3gpp.ngap"

	// KMimeApplicationVnd3gppPfcp
	//
	// English:
	//
	//  Application type 'vnd.3gpp.pfcp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.pfcp'
	KMimeApplicationVnd3gppPfcp Mime = "application/vnd.3gpp.pfcp"

	// KMimeApplicationVnd3gppPicBwLarge
	//
	// English:
	//
	//  Application type 'vnd.3gpp.pic-bw-large'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.pic-bw-large'
	KMimeApplicationVnd3gppPicBwLarge Mime = "application/vnd.3gpp.pic-bw-large"

	// KMimeApplicationVnd3gppPicBwSmall
	//
	// English:
	//
	//  Application type 'vnd.3gpp.pic-bw-small'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.pic-bw-small'
	KMimeApplicationVnd3gppPicBwSmall Mime = "application/vnd.3gpp.pic-bw-small"

	// KMimeApplicationVnd3gppPicBwVar
	//
	// English:
	//
	//  Application type 'vnd.3gpp.pic-bw-var'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.pic-bw-var'
	KMimeApplicationVnd3gppPicBwVar Mime = "application/vnd.3gpp.pic-bw-var"

	// KMimeApplicationVnd3gppProsePc3chXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp-prose-pc3ch+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp-prose-pc3ch+xml'
	KMimeApplicationVnd3gppProsePc3chXml Mime = "application/vnd.3gpp-prose-pc3ch+xml"

	// KMimeApplicationVnd3gppProseXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp-prose+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp-prose+xml'
	KMimeApplicationVnd3gppProseXml Mime = "application/vnd.3gpp-prose+xml"

	// KMimeApplicationVnd3gppS1ap
	//
	// English:
	//
	//  Application type 'vnd.3gpp.s1ap'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.s1ap'
	KMimeApplicationVnd3gppS1ap Mime = "application/vnd.3gpp.s1ap"

	// KMimeApplicationVnd3gppSms
	//
	// English:
	//
	//  Application type 'vnd.3gpp.sms'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.sms'
	KMimeApplicationVnd3gppSms Mime = "application/vnd.3gpp.sms"

	// KMimeApplicationVnd3gppSmsXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.sms+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.sms+xml'
	KMimeApplicationVnd3gppSmsXml Mime = "application/vnd.3gpp.sms+xml"

	// KMimeApplicationVnd3gppSrvccExtXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.srvcc-ext+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.srvcc-ext+xml'
	KMimeApplicationVnd3gppSrvccExtXml Mime = "application/vnd.3gpp.srvcc-ext+xml"

	// KMimeApplicationVnd3gppSRVCCInfoXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.SRVCC-info+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.SRVCC-info+xml'
	KMimeApplicationVnd3gppSRVCCInfoXml Mime = "application/vnd.3gpp.SRVCC-info+xml"

	// KMimeApplicationVnd3gppStateAndEventInfoXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.state-and-event-info+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.state-and-event-info+xml'
	KMimeApplicationVnd3gppStateAndEventInfoXml Mime = "application/vnd.3gpp.state-and-event-info+xml"

	// KMimeApplicationVnd3gppUssdXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.ussd+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.ussd+xml'
	KMimeApplicationVnd3gppUssdXml Mime = "application/vnd.3gpp.ussd+xml"

	// KMimeApplicationVnd3gppV2xLocalServiceInformation
	//
	// English:
	//
	//  Application type 'vnd.3gpp-v2x-local-service-information'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp-v2x-local-service-information'
	KMimeApplicationVnd3gppV2xLocalServiceInformation Mime = "application/vnd.3gpp-v2x-local-service-information"

	// KMimeApplicationVnd3gpp2BcmcsinfoXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp2.bcmcsinfo+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp2.bcmcsinfo+xml'
	KMimeApplicationVnd3gpp2BcmcsinfoXml Mime = "application/vnd.3gpp2.bcmcsinfo+xml"

	// KMimeApplicationVnd3gpp2Sms
	//
	// English:
	//
	//  Application type 'vnd.3gpp2.sms'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp2.sms'
	KMimeApplicationVnd3gpp2Sms Mime = "application/vnd.3gpp2.sms"

	// KMimeApplicationVnd3gpp2Tcap
	//
	// English:
	//
	//  Application type 'vnd.3gpp2.tcap'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp2.tcap'
	KMimeApplicationVnd3gpp2Tcap Mime = "application/vnd.3gpp2.tcap"

	// KMimeApplicationVnd3lightssoftwareImagescal
	//
	// English:
	//
	//  Application type 'vnd.3lightssoftware.imagescal'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3lightssoftware.imagescal'
	KMimeApplicationVnd3lightssoftwareImagescal Mime = "application/vnd.3lightssoftware.imagescal"

	// KMimeApplicationVnd3MPostItNotes
	//
	// English:
	//
	//  Application type 'vnd.3M.Post-it-Notes'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3M.Post-it-Notes'
	KMimeApplicationVnd3MPostItNotes Mime = "application/vnd.3M.Post-it-Notes"

	// KMimeApplicationVndAccpacSimplyAso
	//
	// English:
	//
	//  Application type 'vnd.accpac.simply.aso'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.accpac.simply.aso'
	KMimeApplicationVndAccpacSimplyAso Mime = "application/vnd.accpac.simply.aso"

	// KMimeApplicationVndAccpacSimplyImp
	//
	// English:
	//
	//  Application type 'vnd.accpac.simply.imp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.accpac.simply.imp'
	KMimeApplicationVndAccpacSimplyImp Mime = "application/vnd.accpac.simply.imp"

	// KMimeApplicationVndAcucobol
	//
	// English:
	//
	//  Application type 'vnd.acucobol'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.acucobol'
	KMimeApplicationVndAcucobol Mime = "application/vnd.acucobol"

	// KMimeApplicationVndAcucorp
	//
	// English:
	//
	//  Application type 'vnd.acucorp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.acucorp'
	KMimeApplicationVndAcucorp Mime = "application/vnd.acucorp"

	// KMimeApplicationVndAdobeFlashMovie
	//
	// English:
	//
	//  Application type 'vnd.adobe.flash.movie'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.adobe.flash.movie'
	KMimeApplicationVndAdobeFlashMovie Mime = "application/vnd.adobe.flash.movie"

	// KMimeApplicationVndAdobeFormscentralFcdt
	//
	// English:
	//
	//  Application type 'vnd.adobe.formscentral.fcdt'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.adobe.formscentral.fcdt'
	KMimeApplicationVndAdobeFormscentralFcdt Mime = "application/vnd.adobe.formscentral.fcdt"

	// KMimeApplicationVndAdobeFxp
	//
	// English:
	//
	//  Application type 'vnd.adobe.fxp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.adobe.fxp'
	KMimeApplicationVndAdobeFxp Mime = "application/vnd.adobe.fxp"

	// KMimeApplicationVndAdobePartialUpload
	//
	// English:
	//
	//  Application type 'vnd.adobe.partial-upload'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.adobe.partial-upload'
	KMimeApplicationVndAdobePartialUpload Mime = "application/vnd.adobe.partial-upload"

	// KMimeApplicationVndAdobeXdpXml
	//
	// English:
	//
	//  Application type 'vnd.adobe.xdp+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.adobe.xdp+xml'
	KMimeApplicationVndAdobeXdpXml Mime = "application/vnd.adobe.xdp+xml"

	// KMimeApplicationVndAdobeXfdf
	//
	// English:
	//
	//  Application type 'vnd.adobe.xfdf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.adobe.xfdf'
	KMimeApplicationVndAdobeXfdf Mime = "application/vnd.adobe.xfdf"

	// KMimeApplicationVndAetherImp
	//
	// English:
	//
	//  Application type 'vnd.aether.imp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.aether.imp'
	KMimeApplicationVndAetherImp Mime = "application/vnd.aether.imp"

	// KMimeApplicationVndAfpcAfplinedata
	//
	// English:
	//
	//  Application type 'vnd.afpc.afplinedata'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.afpc.afplinedata'
	KMimeApplicationVndAfpcAfplinedata Mime = "application/vnd.afpc.afplinedata"

	// KMimeApplicationVndAfpcAfplinedataPagedef
	//
	// English:
	//
	//  Application type 'vnd.afpc.afplinedata-pagedef'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.afpc.afplinedata-pagedef'
	KMimeApplicationVndAfpcAfplinedataPagedef Mime = "application/vnd.afpc.afplinedata-pagedef"

	// KMimeApplicationVndAfpcCmocaCmresource
	//
	// English:
	//
	//  Application type 'vnd.afpc.cmoca-cmresource'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.afpc.cmoca-cmresource'
	KMimeApplicationVndAfpcCmocaCmresource Mime = "application/vnd.afpc.cmoca-cmresource"

	// KMimeApplicationVndAfpcFocaCharset
	//
	// English:
	//
	//  Application type 'vnd.afpc.foca-charset'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.afpc.foca-charset'
	KMimeApplicationVndAfpcFocaCharset Mime = "application/vnd.afpc.foca-charset"

	// KMimeApplicationVndAfpcFocaCodedfont
	//
	// English:
	//
	//  Application type 'vnd.afpc.foca-codedfont'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.afpc.foca-codedfont'
	KMimeApplicationVndAfpcFocaCodedfont Mime = "application/vnd.afpc.foca-codedfont"

	// KMimeApplicationVndAfpcFocaCodepage
	//
	// English:
	//
	//  Application type 'vnd.afpc.foca-codepage'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.afpc.foca-codepage'
	KMimeApplicationVndAfpcFocaCodepage Mime = "application/vnd.afpc.foca-codepage"

	// KMimeApplicationVndAfpcModca
	//
	// English:
	//
	//  Application type 'vnd.afpc.modca'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.afpc.modca'
	KMimeApplicationVndAfpcModca Mime = "application/vnd.afpc.modca"

	// KMimeApplicationVndAfpcModcaCmtable
	//
	// English:
	//
	//  Application type 'vnd.afpc.modca-cmtable'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.afpc.modca-cmtable'
	KMimeApplicationVndAfpcModcaCmtable Mime = "application/vnd.afpc.modca-cmtable"

	// KMimeApplicationVndAfpcModcaFormdef
	//
	// English:
	//
	//  Application type 'vnd.afpc.modca-formdef'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.afpc.modca-formdef'
	KMimeApplicationVndAfpcModcaFormdef Mime = "application/vnd.afpc.modca-formdef"

	// KMimeApplicationVndAfpcModcaMediummap
	//
	// English:
	//
	//  Application type 'vnd.afpc.modca-mediummap'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.afpc.modca-mediummap'
	KMimeApplicationVndAfpcModcaMediummap Mime = "application/vnd.afpc.modca-mediummap"

	// KMimeApplicationVndAfpcModcaObjectcontainer
	//
	// English:
	//
	//  Application type 'vnd.afpc.modca-objectcontainer'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.afpc.modca-objectcontainer'
	KMimeApplicationVndAfpcModcaObjectcontainer Mime = "application/vnd.afpc.modca-objectcontainer"

	// KMimeApplicationVndAfpcModcaOverlay
	//
	// English:
	//
	//  Application type 'vnd.afpc.modca-overlay'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.afpc.modca-overlay'
	KMimeApplicationVndAfpcModcaOverlay Mime = "application/vnd.afpc.modca-overlay"

	// KMimeApplicationVndAfpcModcaPagesegment
	//
	// English:
	//
	//  Application type 'vnd.afpc.modca-pagesegment'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.afpc.modca-pagesegment'
	KMimeApplicationVndAfpcModcaPagesegment Mime = "application/vnd.afpc.modca-pagesegment"

	// KMimeApplicationVndAge
	//
	// English:
	//
	//  Application type 'vnd.age'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.age'
	KMimeApplicationVndAge Mime = "application/vnd.age"

	// KMimeApplicationVndAhBarcode
	//
	// English:
	//
	//  Application type 'vnd.ah-barcode'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ah-barcode'
	KMimeApplicationVndAhBarcode Mime = "application/vnd.ah-barcode"

	// KMimeApplicationVndAheadSpace
	//
	// English:
	//
	//  Application type 'vnd.ahead.space'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ahead.space'
	KMimeApplicationVndAheadSpace Mime = "application/vnd.ahead.space"

	// KMimeApplicationVndAirzipFilesecureAzf
	//
	// English:
	//
	//  Application type 'vnd.airzip.filesecure.azf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.airzip.filesecure.azf'
	KMimeApplicationVndAirzipFilesecureAzf Mime = "application/vnd.airzip.filesecure.azf"

	// KMimeApplicationVndAirzipFilesecureAzs
	//
	// English:
	//
	//  Application type 'vnd.airzip.filesecure.azs'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.airzip.filesecure.azs'
	KMimeApplicationVndAirzipFilesecureAzs Mime = "application/vnd.airzip.filesecure.azs"

	// KMimeApplicationVndAmadeusJson
	//
	// English:
	//
	//  Application type 'vnd.amadeus+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.amadeus+json'
	KMimeApplicationVndAmadeusJson Mime = "application/vnd.amadeus+json"

	// KMimeApplicationVndAmazonMobi8Ebook
	//
	// English:
	//
	//  Application type 'vnd.amazon.mobi8-ebook'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.amazon.mobi8-ebook'
	KMimeApplicationVndAmazonMobi8Ebook Mime = "application/vnd.amazon.mobi8-ebook"

	// KMimeApplicationVndAmericandynamicsAcc
	//
	// English:
	//
	//  Application type 'vnd.americandynamics.acc'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.americandynamics.acc'
	KMimeApplicationVndAmericandynamicsAcc Mime = "application/vnd.americandynamics.acc"

	// KMimeApplicationVndAmigaAmi
	//
	// English:
	//
	//  Application type 'vnd.amiga.ami'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.amiga.ami'
	KMimeApplicationVndAmigaAmi Mime = "application/vnd.amiga.ami"

	// KMimeApplicationVndAmundsenMazeXml
	//
	// English:
	//
	//  Application type 'vnd.amundsen.maze+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.amundsen.maze+xml'
	KMimeApplicationVndAmundsenMazeXml Mime = "application/vnd.amundsen.maze+xml"

	// KMimeApplicationVndAndroidOta
	//
	// English:
	//
	//  Application type 'vnd.android.ota'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.android.ota'
	KMimeApplicationVndAndroidOta Mime = "application/vnd.android.ota"

	// KMimeApplicationVndAnki
	//
	// English:
	//
	//  Application type 'vnd.anki'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.anki'
	KMimeApplicationVndAnki Mime = "application/vnd.anki"

	// KMimeApplicationVndAnserWebCertificateIssueInitiation
	//
	// English:
	//
	//  Application type 'vnd.anser-web-certificate-issue-initiation'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.anser-web-certificate-issue-initiation'
	KMimeApplicationVndAnserWebCertificateIssueInitiation Mime = "application/vnd.anser-web-certificate-issue-initiation"

	// KMimeApplicationVndAntixGameComponent
	//
	// English:
	//
	//  Application type 'vnd.antix.game-component'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.antix.game-component'
	KMimeApplicationVndAntixGameComponent Mime = "application/vnd.antix.game-component"

	// KMimeApplicationVndApacheArrowFile
	//
	// English:
	//
	//  Application type 'vnd.apache.arrow.file'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.apache.arrow.file'
	KMimeApplicationVndApacheArrowFile Mime = "application/vnd.apache.arrow.file"

	// KMimeApplicationVndApacheArrowStream
	//
	// English:
	//
	//  Application type 'vnd.apache.arrow.stream'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.apache.arrow.stream'
	KMimeApplicationVndApacheArrowStream Mime = "application/vnd.apache.arrow.stream"

	// KMimeApplicationVndApacheThriftBinary
	//
	// English:
	//
	//  Application type 'vnd.apache.thrift.binary'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.apache.thrift.binary'
	KMimeApplicationVndApacheThriftBinary Mime = "application/vnd.apache.thrift.binary"

	// KMimeApplicationVndApacheThriftCompact
	//
	// English:
	//
	//  Application type 'vnd.apache.thrift.compact'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.apache.thrift.compact'
	KMimeApplicationVndApacheThriftCompact Mime = "application/vnd.apache.thrift.compact"

	// KMimeApplicationVndApacheThriftJson
	//
	// English:
	//
	//  Application type 'vnd.apache.thrift.json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.apache.thrift.json'
	KMimeApplicationVndApacheThriftJson Mime = "application/vnd.apache.thrift.json"

	// KMimeApplicationVndApiJson
	//
	// English:
	//
	//  Application type 'vnd.api+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.api+json'
	KMimeApplicationVndApiJson Mime = "application/vnd.api+json"

	// KMimeApplicationVndAplextorWarrpJson
	//
	// English:
	//
	//  Application type 'vnd.aplextor.warrp+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.aplextor.warrp+json'
	KMimeApplicationVndAplextorWarrpJson Mime = "application/vnd.aplextor.warrp+json"

	// KMimeApplicationVndApothekendeReservationJson
	//
	// English:
	//
	//  Application type 'vnd.apothekende.reservation+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.apothekende.reservation+json'
	KMimeApplicationVndApothekendeReservationJson Mime = "application/vnd.apothekende.reservation+json"

	// KMimeApplicationVndAppleInstallerXml
	//
	// English:
	//
	//  Application type 'vnd.apple.installer+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.apple.installer+xml'
	KMimeApplicationVndAppleInstallerXml Mime = "application/vnd.apple.installer+xml"

	// KMimeApplicationVndAppleKeynote
	//
	// English:
	//
	//  Application type 'vnd.apple.keynote'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.apple.keynote'
	KMimeApplicationVndAppleKeynote Mime = "application/vnd.apple.keynote"

	// KMimeApplicationVndAppleMpegurl
	//
	// English:
	//
	//  Application type 'vnd.apple.mpegurl'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.apple.mpegurl'
	KMimeApplicationVndAppleMpegurl Mime = "application/vnd.apple.mpegurl"

	// KMimeApplicationVndAppleNumbers
	//
	// English:
	//
	//  Application type 'vnd.apple.numbers'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.apple.numbers'
	KMimeApplicationVndAppleNumbers Mime = "application/vnd.apple.numbers"

	// KMimeApplicationVndApplePages
	//
	// English:
	//
	//  Application type 'vnd.apple.pages'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.apple.pages'
	KMimeApplicationVndApplePages Mime = "application/vnd.apple.pages"

	// KMimeApplicationVndArastraSwi
	//
	// English:
	//
	//  Application type 'vnd.arastra.swi'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.arastra.swi'
	KMimeApplicationVndArastraSwi Mime = "(OBSOLETED"

	// KMimeApplicationVndAristanetworksSwi
	//
	// English:
	//
	//  Application type 'vnd.aristanetworks.swi'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.aristanetworks.swi'
	KMimeApplicationVndAristanetworksSwi Mime = "application/vnd.aristanetworks.swi"

	// KMimeApplicationVndArtisanJson
	//
	// English:
	//
	//  Application type 'vnd.artisan+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.artisan+json'
	KMimeApplicationVndArtisanJson Mime = "application/vnd.artisan+json"

	// KMimeApplicationVndArtsquare
	//
	// English:
	//
	//  Application type 'vnd.artsquare'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.artsquare'
	KMimeApplicationVndArtsquare Mime = "application/vnd.artsquare"

	// KMimeApplicationVndAstraeaSoftwareIota
	//
	// English:
	//
	//  Application type 'vnd.astraea-software.iota'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.astraea-software.iota'
	KMimeApplicationVndAstraeaSoftwareIota Mime = "application/vnd.astraea-software.iota"

	// KMimeApplicationVndAudiograph
	//
	// English:
	//
	//  Application type 'vnd.audiograph'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.audiograph'
	KMimeApplicationVndAudiograph Mime = "application/vnd.audiograph"

	// KMimeApplicationVndAutopackage
	//
	// English:
	//
	//  Application type 'vnd.autopackage'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.autopackage'
	KMimeApplicationVndAutopackage Mime = "application/vnd.autopackage"

	// KMimeApplicationVndAvalonJson
	//
	// English:
	//
	//  Application type 'vnd.avalon+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.avalon+json'
	KMimeApplicationVndAvalonJson Mime = "application/vnd.avalon+json"

	// KMimeApplicationVndAvistarXml
	//
	// English:
	//
	//  Application type 'vnd.avistar+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.avistar+xml'
	KMimeApplicationVndAvistarXml Mime = "application/vnd.avistar+xml"

	// KMimeApplicationVndBalsamiqBmmlXml
	//
	// English:
	//
	//  Application type 'vnd.balsamiq.bmml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.balsamiq.bmml+xml'
	KMimeApplicationVndBalsamiqBmmlXml Mime = "application/vnd.balsamiq.bmml+xml"

	// KMimeApplicationVndBananaAccounting
	//
	// English:
	//
	//  Application type 'vnd.banana-accounting'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.banana-accounting'
	KMimeApplicationVndBananaAccounting Mime = "application/vnd.banana-accounting"

	// KMimeApplicationVndBbfUspError
	//
	// English:
	//
	//  Application type 'vnd.bbf.usp.error'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.bbf.usp.error'
	KMimeApplicationVndBbfUspError Mime = "application/vnd.bbf.usp.error"

	// KMimeApplicationVndBbfUspMsg
	//
	// English:
	//
	//  Application type 'vnd.bbf.usp.msg'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.bbf.usp.msg'
	KMimeApplicationVndBbfUspMsg Mime = "application/vnd.bbf.usp.msg"

	// KMimeApplicationVndBbfUspMsgJson
	//
	// English:
	//
	//  Application type 'vnd.bbf.usp.msg+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.bbf.usp.msg+json'
	KMimeApplicationVndBbfUspMsgJson Mime = "application/vnd.bbf.usp.msg+json"

	// KMimeApplicationVndBalsamiqBmpr
	//
	// English:
	//
	//  Application type 'vnd.balsamiq.bmpr'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.balsamiq.bmpr'
	KMimeApplicationVndBalsamiqBmpr Mime = "application/vnd.balsamiq.bmpr"

	// KMimeApplicationVndBekitzurStechJson
	//
	// English:
	//
	//  Application type 'vnd.bekitzur-stech+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.bekitzur-stech+json'
	KMimeApplicationVndBekitzurStechJson Mime = "application/vnd.bekitzur-stech+json"

	// KMimeApplicationVndBintMedContent
	//
	// English:
	//
	//  Application type 'vnd.bint.med-content'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.bint.med-content'
	KMimeApplicationVndBintMedContent Mime = "application/vnd.bint.med-content"

	// KMimeApplicationVndBiopaxRdfXml
	//
	// English:
	//
	//  Application type 'vnd.biopax.rdf+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.biopax.rdf+xml'
	KMimeApplicationVndBiopaxRdfXml Mime = "application/vnd.biopax.rdf+xml"

	// KMimeApplicationVndBlinkIdbValueWrapper
	//
	// English:
	//
	//  Application type 'vnd.blink-idb-value-wrapper'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.blink-idb-value-wrapper'
	KMimeApplicationVndBlinkIdbValueWrapper Mime = "application/vnd.blink-idb-value-wrapper"

	// KMimeApplicationVndBlueiceMultipass
	//
	// English:
	//
	//  Application type 'vnd.blueice.multipass'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.blueice.multipass'
	KMimeApplicationVndBlueiceMultipass Mime = "application/vnd.blueice.multipass"

	// KMimeApplicationVndBluetoothEpOob
	//
	// English:
	//
	//  Application type 'vnd.bluetooth.ep.oob'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.bluetooth.ep.oob'
	KMimeApplicationVndBluetoothEpOob Mime = "application/vnd.bluetooth.ep.oob"

	// KMimeApplicationVndBluetoothLeOob
	//
	// English:
	//
	//  Application type 'vnd.bluetooth.le.oob'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.bluetooth.le.oob'
	KMimeApplicationVndBluetoothLeOob Mime = "application/vnd.bluetooth.le.oob"

	// KMimeApplicationVndBmi
	//
	// English:
	//
	//  Application type 'vnd.bmi'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.bmi'
	KMimeApplicationVndBmi Mime = "application/vnd.bmi"

	// KMimeApplicationVndBpf
	//
	// English:
	//
	//  Application type 'vnd.bpf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.bpf'
	KMimeApplicationVndBpf Mime = "application/vnd.bpf"

	// KMimeApplicationVndBpf3
	//
	// English:
	//
	//  Application type 'vnd.bpf3'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.bpf3'
	KMimeApplicationVndBpf3 Mime = "application/vnd.bpf3"

	// KMimeApplicationVndBusinessobjects
	//
	// English:
	//
	//  Application type 'vnd.businessobjects'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.businessobjects'
	KMimeApplicationVndBusinessobjects Mime = "application/vnd.businessobjects"

	// KMimeApplicationVndByuUapiJson
	//
	// English:
	//
	//  Application type 'vnd.byu.uapi+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.byu.uapi+json'
	KMimeApplicationVndByuUapiJson Mime = "application/vnd.byu.uapi+json"

	// KMimeApplicationVndCabJscript
	//
	// English:
	//
	//  Application type 'vnd.cab-jscript'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cab-jscript'
	KMimeApplicationVndCabJscript Mime = "application/vnd.cab-jscript"

	// KMimeApplicationVndCanonCpdl
	//
	// English:
	//
	//  Application type 'vnd.canon-cpdl'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.canon-cpdl'
	KMimeApplicationVndCanonCpdl Mime = "application/vnd.canon-cpdl"

	// KMimeApplicationVndCanonLips
	//
	// English:
	//
	//  Application type 'vnd.canon-lips'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.canon-lips'
	KMimeApplicationVndCanonLips Mime = "application/vnd.canon-lips"

	// KMimeApplicationVndCapasystemsPgJson
	//
	// English:
	//
	//  Application type 'vnd.capasystems-pg+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.capasystems-pg+json'
	KMimeApplicationVndCapasystemsPgJson Mime = "application/vnd.capasystems-pg+json"

	// KMimeApplicationVndCendioThinlincClientconf
	//
	// English:
	//
	//  Application type 'vnd.cendio.thinlinc.clientconf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cendio.thinlinc.clientconf'
	KMimeApplicationVndCendioThinlincClientconf Mime = "application/vnd.cendio.thinlinc.clientconf"

	// KMimeApplicationVndCenturySystemsTcpStream
	//
	// English:
	//
	//  Application type 'vnd.century-systems.tcp_stream'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.century-systems.tcp_stream'
	KMimeApplicationVndCenturySystemsTcpStream Mime = "application/vnd.century-systems.tcp_stream"

	// KMimeApplicationVndChemdrawXml
	//
	// English:
	//
	//  Application type 'vnd.chemdraw+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.chemdraw+xml'
	KMimeApplicationVndChemdrawXml Mime = "application/vnd.chemdraw+xml"

	// KMimeApplicationVndChessPgn
	//
	// English:
	//
	//  Application type 'vnd.chess-pgn'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.chess-pgn'
	KMimeApplicationVndChessPgn Mime = "application/vnd.chess-pgn"

	// KMimeApplicationVndChipnutsKaraokeMmd
	//
	// English:
	//
	//  Application type 'vnd.chipnuts.karaoke-mmd'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.chipnuts.karaoke-mmd'
	KMimeApplicationVndChipnutsKaraokeMmd Mime = "application/vnd.chipnuts.karaoke-mmd"

	// KMimeApplicationVndCiedi
	//
	// English:
	//
	//  Application type 'vnd.ciedi'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ciedi'
	KMimeApplicationVndCiedi Mime = "application/vnd.ciedi"

	// KMimeApplicationVndCinderella
	//
	// English:
	//
	//  Application type 'vnd.cinderella'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cinderella'
	KMimeApplicationVndCinderella Mime = "application/vnd.cinderella"

	// KMimeApplicationVndCirpackIsdnExt
	//
	// English:
	//
	//  Application type 'vnd.cirpack.isdn-ext'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cirpack.isdn-ext'
	KMimeApplicationVndCirpackIsdnExt Mime = "application/vnd.cirpack.isdn-ext"

	// KMimeApplicationVndCitationstylesStyleXml
	//
	// English:
	//
	//  Application type 'vnd.citationstyles.style+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.citationstyles.style+xml'
	KMimeApplicationVndCitationstylesStyleXml Mime = "application/vnd.citationstyles.style+xml"

	// KMimeApplicationVndClaymore
	//
	// English:
	//
	//  Application type 'vnd.claymore'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.claymore'
	KMimeApplicationVndClaymore Mime = "application/vnd.claymore"

	// KMimeApplicationVndCloantoRp9
	//
	// English:
	//
	//  Application type 'vnd.cloanto.rp9'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cloanto.rp9'
	KMimeApplicationVndCloantoRp9 Mime = "application/vnd.cloanto.rp9"

	// KMimeApplicationVndClonkC4group
	//
	// English:
	//
	//  Application type 'vnd.clonk.c4group'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.clonk.c4group'
	KMimeApplicationVndClonkC4group Mime = "application/vnd.clonk.c4group"

	// KMimeApplicationVndCluetrustCartomobileConfig
	//
	// English:
	//
	//  Application type 'vnd.cluetrust.cartomobile-config'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cluetrust.cartomobile-config'
	KMimeApplicationVndCluetrustCartomobileConfig Mime = "application/vnd.cluetrust.cartomobile-config"

	// KMimeApplicationVndCluetrustCartomobileConfigPkg
	//
	// English:
	//
	//  Application type 'vnd.cluetrust.cartomobile-config-pkg'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cluetrust.cartomobile-config-pkg'
	KMimeApplicationVndCluetrustCartomobileConfigPkg Mime = "application/vnd.cluetrust.cartomobile-config-pkg"

	// KMimeApplicationVndCoffeescript
	//
	// English:
	//
	//  Application type 'vnd.coffeescript'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.coffeescript'
	KMimeApplicationVndCoffeescript Mime = "application/vnd.coffeescript"

	// KMimeApplicationVndCollabioXodocumentsDocument
	//
	// English:
	//
	//  Application type 'vnd.collabio.xodocuments.document'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.collabio.xodocuments.document'
	KMimeApplicationVndCollabioXodocumentsDocument Mime = "application/vnd.collabio.xodocuments.document"

	// KMimeApplicationVndCollabioXodocumentsDocumentTemplate
	//
	// English:
	//
	//  Application type 'vnd.collabio.xodocuments.document-template'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.collabio.xodocuments.document-template'
	KMimeApplicationVndCollabioXodocumentsDocumentTemplate Mime = "application/vnd.collabio.xodocuments.document-template"

	// KMimeApplicationVndCollabioXodocumentsPresentation
	//
	// English:
	//
	//  Application type 'vnd.collabio.xodocuments.presentation'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.collabio.xodocuments.presentation'
	KMimeApplicationVndCollabioXodocumentsPresentation Mime = "application/vnd.collabio.xodocuments.presentation"

	// KMimeApplicationVndCollabioXodocumentsPresentationTemplate
	//
	// English:
	//
	//  Application type 'vnd.collabio.xodocuments.presentation-template'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.collabio.xodocuments.presentation-template'
	KMimeApplicationVndCollabioXodocumentsPresentationTemplate Mime = "application/vnd.collabio.xodocuments.presentation-template"

	// KMimeApplicationVndCollabioXodocumentsSpreadsheet
	//
	// English:
	//
	//  Application type 'vnd.collabio.xodocuments.spreadsheet'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.collabio.xodocuments.spreadsheet'
	KMimeApplicationVndCollabioXodocumentsSpreadsheet Mime = "application/vnd.collabio.xodocuments.spreadsheet"

	// KMimeApplicationVndCollabioXodocumentsSpreadsheetTemplate
	//
	// English:
	//
	//  Application type 'vnd.collabio.xodocuments.spreadsheet-template'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.collabio.xodocuments.spreadsheet-template'
	KMimeApplicationVndCollabioXodocumentsSpreadsheetTemplate Mime = "application/vnd.collabio.xodocuments.spreadsheet-template"

	// KMimeApplicationVndCollectionDocJson
	//
	// English:
	//
	//  Application type 'vnd.collection.doc+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.collection.doc+json'
	KMimeApplicationVndCollectionDocJson Mime = "application/vnd.collection.doc+json"

	// KMimeApplicationVndCollectionJson
	//
	// English:
	//
	//  Application type 'vnd.collection+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.collection+json'
	KMimeApplicationVndCollectionJson Mime = "application/vnd.collection+json"

	// KMimeApplicationVndCollectionNextJson
	//
	// English:
	//
	//  Application type 'vnd.collection.next+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.collection.next+json'
	KMimeApplicationVndCollectionNextJson Mime = "application/vnd.collection.next+json"

	// KMimeApplicationVndComicbookRar
	//
	// English:
	//
	//  Application type 'vnd.comicbook-rar'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.comicbook-rar'
	KMimeApplicationVndComicbookRar Mime = "application/vnd.comicbook-rar"

	// KMimeApplicationVndComicbookZip
	//
	// English:
	//
	//  Application type 'vnd.comicbook+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.comicbook+zip'
	KMimeApplicationVndComicbookZip Mime = "application/vnd.comicbook+zip"

	// KMimeApplicationVndCommerceBattelle
	//
	// English:
	//
	//  Application type 'vnd.commerce-battelle'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.commerce-battelle'
	KMimeApplicationVndCommerceBattelle Mime = "application/vnd.commerce-battelle"

	// KMimeApplicationVndCommonspace
	//
	// English:
	//
	//  Application type 'vnd.commonspace'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.commonspace'
	KMimeApplicationVndCommonspace Mime = "application/vnd.commonspace"

	// KMimeApplicationVndCoreosIgnitionJson
	//
	// English:
	//
	//  Application type 'vnd.coreos.ignition+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.coreos.ignition+json'
	KMimeApplicationVndCoreosIgnitionJson Mime = "application/vnd.coreos.ignition+json"

	// KMimeApplicationVndCosmocaller
	//
	// English:
	//
	//  Application type 'vnd.cosmocaller'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cosmocaller'
	KMimeApplicationVndCosmocaller Mime = "application/vnd.cosmocaller"

	// KMimeApplicationVndContactCmsg
	//
	// English:
	//
	//  Application type 'vnd.contact.cmsg'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.contact.cmsg'
	KMimeApplicationVndContactCmsg Mime = "application/vnd.contact.cmsg"

	// KMimeApplicationVndCrickClicker
	//
	// English:
	//
	//  Application type 'vnd.crick.clicker'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.crick.clicker'
	KMimeApplicationVndCrickClicker Mime = "application/vnd.crick.clicker"

	// KMimeApplicationVndCrickClickerKeyboard
	//
	// English:
	//
	//  Application type 'vnd.crick.clicker.keyboard'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.crick.clicker.keyboard'
	KMimeApplicationVndCrickClickerKeyboard Mime = "application/vnd.crick.clicker.keyboard"

	// KMimeApplicationVndCrickClickerPalette
	//
	// English:
	//
	//  Application type 'vnd.crick.clicker.palette'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.crick.clicker.palette'
	KMimeApplicationVndCrickClickerPalette Mime = "application/vnd.crick.clicker.palette"

	// KMimeApplicationVndCrickClickerTemplate
	//
	// English:
	//
	//  Application type 'vnd.crick.clicker.template'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.crick.clicker.template'
	KMimeApplicationVndCrickClickerTemplate Mime = "application/vnd.crick.clicker.template"

	// KMimeApplicationVndCrickClickerWordbank
	//
	// English:
	//
	//  Application type 'vnd.crick.clicker.wordbank'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.crick.clicker.wordbank'
	KMimeApplicationVndCrickClickerWordbank Mime = "application/vnd.crick.clicker.wordbank"

	// KMimeApplicationVndCriticaltoolsWbsXml
	//
	// English:
	//
	//  Application type 'vnd.criticaltools.wbs+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.criticaltools.wbs+xml'
	KMimeApplicationVndCriticaltoolsWbsXml Mime = "application/vnd.criticaltools.wbs+xml"

	// KMimeApplicationVndCryptiiPipeJson
	//
	// English:
	//
	//  Application type 'vnd.cryptii.pipe+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cryptii.pipe+json'
	KMimeApplicationVndCryptiiPipeJson Mime = "application/vnd.cryptii.pipe+json"

	// KMimeApplicationVndCryptoShadeFile
	//
	// English:
	//
	//  Application type 'vnd.crypto-shade-file'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.crypto-shade-file'
	KMimeApplicationVndCryptoShadeFile Mime = "application/vnd.crypto-shade-file"

	// KMimeApplicationVndCryptomatorEncrypted
	//
	// English:
	//
	//  Application type 'vnd.cryptomator.encrypted'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cryptomator.encrypted'
	KMimeApplicationVndCryptomatorEncrypted Mime = "application/vnd.cryptomator.encrypted"

	// KMimeApplicationVndCryptomatorVault
	//
	// English:
	//
	//  Application type 'vnd.cryptomator.vault'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cryptomator.vault'
	KMimeApplicationVndCryptomatorVault Mime = "application/vnd.cryptomator.vault"

	// KMimeApplicationVndCtcPosml
	//
	// English:
	//
	//  Application type 'vnd.ctc-posml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ctc-posml'
	KMimeApplicationVndCtcPosml Mime = "application/vnd.ctc-posml"

	// KMimeApplicationVndCtctWsXml
	//
	// English:
	//
	//  Application type 'vnd.ctct.ws+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ctct.ws+xml'
	KMimeApplicationVndCtctWsXml Mime = "application/vnd.ctct.ws+xml"

	// KMimeApplicationVndCupsPdf
	//
	// English:
	//
	//  Application type 'vnd.cups-pdf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cups-pdf'
	KMimeApplicationVndCupsPdf Mime = "application/vnd.cups-pdf"

	// KMimeApplicationVndCupsPostscript
	//
	// English:
	//
	//  Application type 'vnd.cups-postscript'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cups-postscript'
	KMimeApplicationVndCupsPostscript Mime = "application/vnd.cups-postscript"

	// KMimeApplicationVndCupsPpd
	//
	// English:
	//
	//  Application type 'vnd.cups-ppd'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cups-ppd'
	KMimeApplicationVndCupsPpd Mime = "application/vnd.cups-ppd"

	// KMimeApplicationVndCupsRaster
	//
	// English:
	//
	//  Application type 'vnd.cups-raster'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cups-raster'
	KMimeApplicationVndCupsRaster Mime = "application/vnd.cups-raster"

	// KMimeApplicationVndCupsRaw
	//
	// English:
	//
	//  Application type 'vnd.cups-raw'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cups-raw'
	KMimeApplicationVndCupsRaw Mime = "application/vnd.cups-raw"

	// KMimeApplicationVndCurl
	//
	// English:
	//
	//  Application type 'vnd.curl'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.curl'
	KMimeApplicationVndCurl Mime = "application/vnd.curl"

	// KMimeApplicationVndCyanDeanRootXml
	//
	// English:
	//
	//  Application type 'vnd.cyan.dean.root+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cyan.dean.root+xml'
	KMimeApplicationVndCyanDeanRootXml Mime = "application/vnd.cyan.dean.root+xml"

	// KMimeApplicationVndCybank
	//
	// English:
	//
	//  Application type 'vnd.cybank'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cybank'
	KMimeApplicationVndCybank Mime = "application/vnd.cybank"

	// KMimeApplicationVndCyclonedxJson
	//
	// English:
	//
	//  Application type 'vnd.cyclonedx+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cyclonedx+json'
	KMimeApplicationVndCyclonedxJson Mime = "application/vnd.cyclonedx+json"

	// KMimeApplicationVndCyclonedxXml
	//
	// English:
	//
	//  Application type 'vnd.cyclonedx+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cyclonedx+xml'
	KMimeApplicationVndCyclonedxXml Mime = "application/vnd.cyclonedx+xml"

	// KMimeApplicationVndD2lCoursepackage1p0Zip
	//
	// English:
	//
	//  Application type 'vnd.d2l.coursepackage1p0+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.d2l.coursepackage1p0+zip'
	KMimeApplicationVndD2lCoursepackage1p0Zip Mime = "application/vnd.d2l.coursepackage1p0+zip"

	// KMimeApplicationVndD3mDataset
	//
	// English:
	//
	//  Application type 'vnd.d3m-dataset'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.d3m-dataset'
	KMimeApplicationVndD3mDataset Mime = "application/vnd.d3m-dataset"

	// KMimeApplicationVndD3mProblem
	//
	// English:
	//
	//  Application type 'vnd.d3m-problem'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.d3m-problem'
	KMimeApplicationVndD3mProblem Mime = "application/vnd.d3m-problem"

	// KMimeApplicationVndDart
	//
	// English:
	//
	//  Application type 'vnd.dart'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dart'
	KMimeApplicationVndDart Mime = "application/vnd.dart"

	// KMimeApplicationVndDataVisionRdz
	//
	// English:
	//
	//  Application type 'vnd.data-vision.rdz'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.data-vision.rdz'
	KMimeApplicationVndDataVisionRdz Mime = "application/vnd.data-vision.rdz"

	// KMimeApplicationVndDatapackageJson
	//
	// English:
	//
	//  Application type 'vnd.datapackage+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.datapackage+json'
	KMimeApplicationVndDatapackageJson Mime = "application/vnd.datapackage+json"

	// KMimeApplicationVndDataresourceJson
	//
	// English:
	//
	//  Application type 'vnd.dataresource+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dataresource+json'
	KMimeApplicationVndDataresourceJson Mime = "application/vnd.dataresource+json"

	// KMimeApplicationVndDbf
	//
	// English:
	//
	//  Application type 'vnd.dbf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dbf'
	KMimeApplicationVndDbf Mime = "application/vnd.dbf"

	// KMimeApplicationVndDebianBinaryPackage
	//
	// English:
	//
	//  Application type 'vnd.debian.binary-package'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.debian.binary-package'
	KMimeApplicationVndDebianBinaryPackage Mime = "application/vnd.debian.binary-package"

	// KMimeApplicationVndDeceData
	//
	// English:
	//
	//  Application type 'vnd.dece.data'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dece.data'
	KMimeApplicationVndDeceData Mime = "application/vnd.dece.data"

	// KMimeApplicationVndDeceTtmlXml
	//
	// English:
	//
	//  Application type 'vnd.dece.ttml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dece.ttml+xml'
	KMimeApplicationVndDeceTtmlXml Mime = "application/vnd.dece.ttml+xml"

	// KMimeApplicationVndDeceUnspecified
	//
	// English:
	//
	//  Application type 'vnd.dece.unspecified'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dece.unspecified'
	KMimeApplicationVndDeceUnspecified Mime = "application/vnd.dece.unspecified"

	// KMimeApplicationVndDeceZip
	//
	// English:
	//
	//  Application type 'vnd.dece.zip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dece.zip'
	KMimeApplicationVndDeceZip Mime = "application/vnd.dece.zip"

	// KMimeApplicationVndDenovoFcselayoutLink
	//
	// English:
	//
	//  Application type 'vnd.denovo.fcselayout-link'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.denovo.fcselayout-link'
	KMimeApplicationVndDenovoFcselayoutLink Mime = "application/vnd.denovo.fcselayout-link"

	// KMimeApplicationVndDesmumeMovie
	//
	// English:
	//
	//  Application type 'vnd.desmume.movie'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.desmume.movie'
	KMimeApplicationVndDesmumeMovie Mime = "application/vnd.desmume.movie"

	// KMimeApplicationVndDirBiPlateDlNosuffix
	//
	// English:
	//
	//  Application type 'vnd.dir-bi.plate-dl-nosuffix'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dir-bi.plate-dl-nosuffix'
	KMimeApplicationVndDirBiPlateDlNosuffix Mime = "application/vnd.dir-bi.plate-dl-nosuffix"

	// KMimeApplicationVndDmDelegationXml
	//
	// English:
	//
	//  Application type 'vnd.dm.delegation+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dm.delegation+xml'
	KMimeApplicationVndDmDelegationXml Mime = "application/vnd.dm.delegation+xml"

	// KMimeApplicationVndDna
	//
	// English:
	//
	//  Application type 'vnd.dna'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dna'
	KMimeApplicationVndDna Mime = "application/vnd.dna"

	// KMimeApplicationVndDocumentJson
	//
	// English:
	//
	//  Application type 'vnd.document+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.document+json'
	KMimeApplicationVndDocumentJson Mime = "application/vnd.document+json"

	// KMimeApplicationVndDolbyMobile1
	//
	// English:
	//
	//  Application type 'vnd.dolby.mobile.1'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dolby.mobile.1'
	KMimeApplicationVndDolbyMobile1 Mime = "application/vnd.dolby.mobile.1"

	// KMimeApplicationVndDolbyMobile2
	//
	// English:
	//
	//  Application type 'vnd.dolby.mobile.2'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dolby.mobile.2'
	KMimeApplicationVndDolbyMobile2 Mime = "application/vnd.dolby.mobile.2"

	// KMimeApplicationVndDoremirScorecloudBinaryDocument
	//
	// English:
	//
	//  Application type 'vnd.doremir.scorecloud-binary-document'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.doremir.scorecloud-binary-document'
	KMimeApplicationVndDoremirScorecloudBinaryDocument Mime = "application/vnd.doremir.scorecloud-binary-document"

	// KMimeApplicationVndDpgraph
	//
	// English:
	//
	//  Application type 'vnd.dpgraph'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dpgraph'
	KMimeApplicationVndDpgraph Mime = "application/vnd.dpgraph"

	// KMimeApplicationVndDreamfactory
	//
	// English:
	//
	//  Application type 'vnd.dreamfactory'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dreamfactory'
	KMimeApplicationVndDreamfactory Mime = "application/vnd.dreamfactory"

	// KMimeApplicationVndDriveJson
	//
	// English:
	//
	//  Application type 'vnd.drive+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.drive+json'
	KMimeApplicationVndDriveJson Mime = "application/vnd.drive+json"

	// KMimeApplicationVndDtgLocal
	//
	// English:
	//
	//  Application type 'vnd.dtg.local'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dtg.local'
	KMimeApplicationVndDtgLocal Mime = "application/vnd.dtg.local"

	// KMimeApplicationVndDtgLocalFlash
	//
	// English:
	//
	//  Application type 'vnd.dtg.local.flash'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dtg.local.flash'
	KMimeApplicationVndDtgLocalFlash Mime = "application/vnd.dtg.local.flash"

	// KMimeApplicationVndDtgLocalHtml
	//
	// English:
	//
	//  Application type 'vnd.dtg.local.html'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dtg.local.html'
	KMimeApplicationVndDtgLocalHtml Mime = "application/vnd.dtg.local.html"

	// KMimeApplicationVndDvbAit
	//
	// English:
	//
	//  Application type 'vnd.dvb.ait'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.ait'
	KMimeApplicationVndDvbAit Mime = "application/vnd.dvb.ait"

	// KMimeApplicationVndDvbDvbislXml
	//
	// English:
	//
	//  Application type 'vnd.dvb.dvbisl+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.dvbisl+xml'
	KMimeApplicationVndDvbDvbislXml Mime = "application/vnd.dvb.dvbisl+xml"

	// KMimeApplicationVndDvbDvbj
	//
	// English:
	//
	//  Application type 'vnd.dvb.dvbj'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.dvbj'
	KMimeApplicationVndDvbDvbj Mime = "application/vnd.dvb.dvbj"

	// KMimeApplicationVndDvbEsgcontainer
	//
	// English:
	//
	//  Application type 'vnd.dvb.esgcontainer'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.esgcontainer'
	KMimeApplicationVndDvbEsgcontainer Mime = "application/vnd.dvb.esgcontainer"

	// KMimeApplicationVndDvbIpdcdftnotifaccess
	//
	// English:
	//
	//  Application type 'vnd.dvb.ipdcdftnotifaccess'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.ipdcdftnotifaccess'
	KMimeApplicationVndDvbIpdcdftnotifaccess Mime = "application/vnd.dvb.ipdcdftnotifaccess"

	// KMimeApplicationVndDvbIpdcesgaccess
	//
	// English:
	//
	//  Application type 'vnd.dvb.ipdcesgaccess'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.ipdcesgaccess'
	KMimeApplicationVndDvbIpdcesgaccess Mime = "application/vnd.dvb.ipdcesgaccess"

	// KMimeApplicationVndDvbIpdcesgaccess2
	//
	// English:
	//
	//  Application type 'vnd.dvb.ipdcesgaccess2'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.ipdcesgaccess2'
	KMimeApplicationVndDvbIpdcesgaccess2 Mime = "application/vnd.dvb.ipdcesgaccess2"

	// KMimeApplicationVndDvbIpdcesgpdd
	//
	// English:
	//
	//  Application type 'vnd.dvb.ipdcesgpdd'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.ipdcesgpdd'
	KMimeApplicationVndDvbIpdcesgpdd Mime = "application/vnd.dvb.ipdcesgpdd"

	// KMimeApplicationVndDvbIpdcroaming
	//
	// English:
	//
	//  Application type 'vnd.dvb.ipdcroaming'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.ipdcroaming'
	KMimeApplicationVndDvbIpdcroaming Mime = "application/vnd.dvb.ipdcroaming"

	// KMimeApplicationVndDvbIptvAlfecBase
	//
	// English:
	//
	//  Application type 'vnd.dvb.iptv.alfec-base'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.iptv.alfec-base'
	KMimeApplicationVndDvbIptvAlfecBase Mime = "application/vnd.dvb.iptv.alfec-base"

	// KMimeApplicationVndDvbIptvAlfecEnhancement
	//
	// English:
	//
	//  Application type 'vnd.dvb.iptv.alfec-enhancement'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.iptv.alfec-enhancement'
	KMimeApplicationVndDvbIptvAlfecEnhancement Mime = "application/vnd.dvb.iptv.alfec-enhancement"

	// KMimeApplicationVndDvbNotifAggregateRootXml
	//
	// English:
	//
	//  Application type 'vnd.dvb.notif-aggregate-root+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.notif-aggregate-root+xml'
	KMimeApplicationVndDvbNotifAggregateRootXml Mime = "application/vnd.dvb.notif-aggregate-root+xml"

	// KMimeApplicationVndDvbNotifContainerXml
	//
	// English:
	//
	//  Application type 'vnd.dvb.notif-container+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.notif-container+xml'
	KMimeApplicationVndDvbNotifContainerXml Mime = "application/vnd.dvb.notif-container+xml"

	// KMimeApplicationVndDvbNotifGenericXml
	//
	// English:
	//
	//  Application type 'vnd.dvb.notif-generic+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.notif-generic+xml'
	KMimeApplicationVndDvbNotifGenericXml Mime = "application/vnd.dvb.notif-generic+xml"

	// KMimeApplicationVndDvbNotifIaMsglistXml
	//
	// English:
	//
	//  Application type 'vnd.dvb.notif-ia-msglist+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.notif-ia-msglist+xml'
	KMimeApplicationVndDvbNotifIaMsglistXml Mime = "application/vnd.dvb.notif-ia-msglist+xml"

	// KMimeApplicationVndDvbNotifIaRegistrationRequestXml
	//
	// English:
	//
	//  Application type 'vnd.dvb.notif-ia-registration-request+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.notif-ia-registration-request+xml'
	KMimeApplicationVndDvbNotifIaRegistrationRequestXml Mime = "application/vnd.dvb.notif-ia-registration-request+xml"

	// KMimeApplicationVndDvbNotifIaRegistrationResponseXml
	//
	// English:
	//
	//  Application type 'vnd.dvb.notif-ia-registration-response+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.notif-ia-registration-response+xml'
	KMimeApplicationVndDvbNotifIaRegistrationResponseXml Mime = "application/vnd.dvb.notif-ia-registration-response+xml"

	// KMimeApplicationVndDvbNotifInitXml
	//
	// English:
	//
	//  Application type 'vnd.dvb.notif-init+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.notif-init+xml'
	KMimeApplicationVndDvbNotifInitXml Mime = "application/vnd.dvb.notif-init+xml"

	// KMimeApplicationVndDvbPfr
	//
	// English:
	//
	//  Application type 'vnd.dvb.pfr'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.pfr'
	KMimeApplicationVndDvbPfr Mime = "application/vnd.dvb.pfr"

	// KMimeApplicationVndDvbService
	//
	// English:
	//
	//  Application type 'vnd.dvb.service'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.service'
	KMimeApplicationVndDvbService Mime = "application/vnd.dvb.service"

	// KMimeApplicationVndDxr
	//
	// English:
	//
	//  Application type 'vnd.dxr'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dxr'
	KMimeApplicationVndDxr Mime = "application/vnd.dxr"

	// KMimeApplicationVndDynageo
	//
	// English:
	//
	//  Application type 'vnd.dynageo'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dynageo'
	KMimeApplicationVndDynageo Mime = "application/vnd.dynageo"

	// KMimeApplicationVndDzr
	//
	// English:
	//
	//  Application type 'vnd.dzr'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dzr'
	KMimeApplicationVndDzr Mime = "application/vnd.dzr"

	// KMimeApplicationVndEasykaraokeCdgdownload
	//
	// English:
	//
	//  Application type 'vnd.easykaraoke.cdgdownload'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.easykaraoke.cdgdownload'
	KMimeApplicationVndEasykaraokeCdgdownload Mime = "application/vnd.easykaraoke.cdgdownload"

	// KMimeApplicationVndEcipRlp
	//
	// English:
	//
	//  Application type 'vnd.ecip.rlp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ecip.rlp'
	KMimeApplicationVndEcipRlp Mime = "application/vnd.ecip.rlp"

	// KMimeApplicationVndEcdisUpdate
	//
	// English:
	//
	//  Application type 'vnd.ecdis-update'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ecdis-update'
	KMimeApplicationVndEcdisUpdate Mime = "application/vnd.ecdis-update"

	// KMimeApplicationVndEclipseDittoJson
	//
	// English:
	//
	//  Application type 'vnd.eclipse.ditto+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.eclipse.ditto+json'
	KMimeApplicationVndEclipseDittoJson Mime = "application/vnd.eclipse.ditto+json"

	// KMimeApplicationVndEcowinChart
	//
	// English:
	//
	//  Application type 'vnd.ecowin.chart'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ecowin.chart'
	KMimeApplicationVndEcowinChart Mime = "application/vnd.ecowin.chart"

	// KMimeApplicationVndEcowinFilerequest
	//
	// English:
	//
	//  Application type 'vnd.ecowin.filerequest'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ecowin.filerequest'
	KMimeApplicationVndEcowinFilerequest Mime = "application/vnd.ecowin.filerequest"

	// KMimeApplicationVndEcowinFileupdate
	//
	// English:
	//
	//  Application type 'vnd.ecowin.fileupdate'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ecowin.fileupdate'
	KMimeApplicationVndEcowinFileupdate Mime = "application/vnd.ecowin.fileupdate"

	// KMimeApplicationVndEcowinSeries
	//
	// English:
	//
	//  Application type 'vnd.ecowin.series'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ecowin.series'
	KMimeApplicationVndEcowinSeries Mime = "application/vnd.ecowin.series"

	// KMimeApplicationVndEcowinSeriesrequest
	//
	// English:
	//
	//  Application type 'vnd.ecowin.seriesrequest'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ecowin.seriesrequest'
	KMimeApplicationVndEcowinSeriesrequest Mime = "application/vnd.ecowin.seriesrequest"

	// KMimeApplicationVndEcowinSeriesupdate
	//
	// English:
	//
	//  Application type 'vnd.ecowin.seriesupdate'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ecowin.seriesupdate'
	KMimeApplicationVndEcowinSeriesupdate Mime = "application/vnd.ecowin.seriesupdate"

	// KMimeApplicationVndEfiImg
	//
	// English:
	//
	//  Application type 'vnd.efi.img'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.efi.img'
	KMimeApplicationVndEfiImg Mime = "application/vnd.efi.img"

	// KMimeApplicationVndEfiIso
	//
	// English:
	//
	//  Application type 'vnd.efi.iso'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.efi.iso'
	KMimeApplicationVndEfiIso Mime = "application/vnd.efi.iso"

	// KMimeApplicationVndEmclientAccessrequestXml
	//
	// English:
	//
	//  Application type 'vnd.emclient.accessrequest+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.emclient.accessrequest+xml'
	KMimeApplicationVndEmclientAccessrequestXml Mime = "application/vnd.emclient.accessrequest+xml"

	// KMimeApplicationVndEnliven
	//
	// English:
	//
	//  Application type 'vnd.enliven'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.enliven'
	KMimeApplicationVndEnliven Mime = "application/vnd.enliven"

	// KMimeApplicationVndEnphaseEnvoy
	//
	// English:
	//
	//  Application type 'vnd.enphase.envoy'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.enphase.envoy'
	KMimeApplicationVndEnphaseEnvoy Mime = "application/vnd.enphase.envoy"

	// KMimeApplicationVndEprintsDataXml
	//
	// English:
	//
	//  Application type 'vnd.eprints.data+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.eprints.data+xml'
	KMimeApplicationVndEprintsDataXml Mime = "application/vnd.eprints.data+xml"

	// KMimeApplicationVndEpsonEsf
	//
	// English:
	//
	//  Application type 'vnd.epson.esf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.epson.esf'
	KMimeApplicationVndEpsonEsf Mime = "application/vnd.epson.esf"

	// KMimeApplicationVndEpsonMsf
	//
	// English:
	//
	//  Application type 'vnd.epson.msf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.epson.msf'
	KMimeApplicationVndEpsonMsf Mime = "application/vnd.epson.msf"

	// KMimeApplicationVndEpsonQuickanime
	//
	// English:
	//
	//  Application type 'vnd.epson.quickanime'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.epson.quickanime'
	KMimeApplicationVndEpsonQuickanime Mime = "application/vnd.epson.quickanime"

	// KMimeApplicationVndEpsonSalt
	//
	// English:
	//
	//  Application type 'vnd.epson.salt'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.epson.salt'
	KMimeApplicationVndEpsonSalt Mime = "application/vnd.epson.salt"

	// KMimeApplicationVndEpsonSsf
	//
	// English:
	//
	//  Application type 'vnd.epson.ssf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.epson.ssf'
	KMimeApplicationVndEpsonSsf Mime = "application/vnd.epson.ssf"

	// KMimeApplicationVndEricssonQuickcall
	//
	// English:
	//
	//  Application type 'vnd.ericsson.quickcall'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ericsson.quickcall'
	KMimeApplicationVndEricssonQuickcall Mime = "application/vnd.ericsson.quickcall"

	// KMimeApplicationVndEspassEspassZip
	//
	// English:
	//
	//  Application type 'vnd.espass-espass+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.espass-espass+zip'
	KMimeApplicationVndEspassEspassZip Mime = "application/vnd.espass-espass+zip"

	// KMimeApplicationVndEszigno3Xml
	//
	// English:
	//
	//  Application type 'vnd.eszigno3+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.eszigno3+xml'
	KMimeApplicationVndEszigno3Xml Mime = "application/vnd.eszigno3+xml"

	// KMimeApplicationVndEtsiAocXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.aoc+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.aoc+xml'
	KMimeApplicationVndEtsiAocXml Mime = "application/vnd.etsi.aoc+xml"

	// KMimeApplicationVndEtsiAsicSZip
	//
	// English:
	//
	//  Application type 'vnd.etsi.asic-s+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.asic-s+zip'
	KMimeApplicationVndEtsiAsicSZip Mime = "application/vnd.etsi.asic-s+zip"

	// KMimeApplicationVndEtsiAsicEZip
	//
	// English:
	//
	//  Application type 'vnd.etsi.asic-e+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.asic-e+zip'
	KMimeApplicationVndEtsiAsicEZip Mime = "application/vnd.etsi.asic-e+zip"

	// KMimeApplicationVndEtsiCugXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.cug+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.cug+xml'
	KMimeApplicationVndEtsiCugXml Mime = "application/vnd.etsi.cug+xml"

	// KMimeApplicationVndEtsiIptvcommandXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.iptvcommand+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.iptvcommand+xml'
	KMimeApplicationVndEtsiIptvcommandXml Mime = "application/vnd.etsi.iptvcommand+xml"

	// KMimeApplicationVndEtsiIptvdiscoveryXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.iptvdiscovery+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.iptvdiscovery+xml'
	KMimeApplicationVndEtsiIptvdiscoveryXml Mime = "application/vnd.etsi.iptvdiscovery+xml"

	// KMimeApplicationVndEtsiIptvprofileXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.iptvprofile+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.iptvprofile+xml'
	KMimeApplicationVndEtsiIptvprofileXml Mime = "application/vnd.etsi.iptvprofile+xml"

	// KMimeApplicationVndEtsiIptvsadBcXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.iptvsad-bc+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.iptvsad-bc+xml'
	KMimeApplicationVndEtsiIptvsadBcXml Mime = "application/vnd.etsi.iptvsad-bc+xml"

	// KMimeApplicationVndEtsiIptvsadCodXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.iptvsad-cod+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.iptvsad-cod+xml'
	KMimeApplicationVndEtsiIptvsadCodXml Mime = "application/vnd.etsi.iptvsad-cod+xml"

	// KMimeApplicationVndEtsiIptvsadNpvrXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.iptvsad-npvr+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.iptvsad-npvr+xml'
	KMimeApplicationVndEtsiIptvsadNpvrXml Mime = "application/vnd.etsi.iptvsad-npvr+xml"

	// KMimeApplicationVndEtsiIptvserviceXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.iptvservice+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.iptvservice+xml'
	KMimeApplicationVndEtsiIptvserviceXml Mime = "application/vnd.etsi.iptvservice+xml"

	// KMimeApplicationVndEtsiIptvsyncXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.iptvsync+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.iptvsync+xml'
	KMimeApplicationVndEtsiIptvsyncXml Mime = "application/vnd.etsi.iptvsync+xml"

	// KMimeApplicationVndEtsiIptvueprofileXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.iptvueprofile+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.iptvueprofile+xml'
	KMimeApplicationVndEtsiIptvueprofileXml Mime = "application/vnd.etsi.iptvueprofile+xml"

	// KMimeApplicationVndEtsiMcidXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.mcid+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.mcid+xml'
	KMimeApplicationVndEtsiMcidXml Mime = "application/vnd.etsi.mcid+xml"

	// KMimeApplicationVndEtsiMheg5
	//
	// English:
	//
	//  Application type 'vnd.etsi.mheg5'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.mheg5'
	KMimeApplicationVndEtsiMheg5 Mime = "application/vnd.etsi.mheg5"

	// KMimeApplicationVndEtsiOverloadControlPolicyDatasetXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.overload-control-policy-dataset+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.overload-control-policy-dataset+xml'
	KMimeApplicationVndEtsiOverloadControlPolicyDatasetXml Mime = "application/vnd.etsi.overload-control-policy-dataset+xml"

	// KMimeApplicationVndEtsiPstnXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.pstn+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.pstn+xml'
	KMimeApplicationVndEtsiPstnXml Mime = "application/vnd.etsi.pstn+xml"

	// KMimeApplicationVndEtsiSciXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.sci+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.sci+xml'
	KMimeApplicationVndEtsiSciXml Mime = "application/vnd.etsi.sci+xml"

	// KMimeApplicationVndEtsiSimservsXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.simservs+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.simservs+xml'
	KMimeApplicationVndEtsiSimservsXml Mime = "application/vnd.etsi.simservs+xml"

	// KMimeApplicationVndEtsiTimestampToken
	//
	// English:
	//
	//  Application type 'vnd.etsi.timestamp-token'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.timestamp-token'
	KMimeApplicationVndEtsiTimestampToken Mime = "application/vnd.etsi.timestamp-token"

	// KMimeApplicationVndEtsiTslXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.tsl+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.tsl+xml'
	KMimeApplicationVndEtsiTslXml Mime = "application/vnd.etsi.tsl+xml"

	// KMimeApplicationVndEtsiTslDer
	//
	// English:
	//
	//  Application type 'vnd.etsi.tsl.der'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.tsl.der'
	KMimeApplicationVndEtsiTslDer Mime = "application/vnd.etsi.tsl.der"

	// KMimeApplicationVndEuKasparianCarJson
	//
	// English:
	//
	//  Application type 'vnd.eu.kasparian.car+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.eu.kasparian.car+json'
	KMimeApplicationVndEuKasparianCarJson Mime = "application/vnd.eu.kasparian.car+json"

	// KMimeApplicationVndEudoraData
	//
	// English:
	//
	//  Application type 'vnd.eudora.data'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.eudora.data'
	KMimeApplicationVndEudoraData Mime = "application/vnd.eudora.data"

	// KMimeApplicationVndEvolvEcigProfile
	//
	// English:
	//
	//  Application type 'vnd.evolv.ecig.profile'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.evolv.ecig.profile'
	KMimeApplicationVndEvolvEcigProfile Mime = "application/vnd.evolv.ecig.profile"

	// KMimeApplicationVndEvolvEcigSettings
	//
	// English:
	//
	//  Application type 'vnd.evolv.ecig.settings'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.evolv.ecig.settings'
	KMimeApplicationVndEvolvEcigSettings Mime = "application/vnd.evolv.ecig.settings"

	// KMimeApplicationVndEvolvEcigTheme
	//
	// English:
	//
	//  Application type 'vnd.evolv.ecig.theme'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.evolv.ecig.theme'
	KMimeApplicationVndEvolvEcigTheme Mime = "application/vnd.evolv.ecig.theme"

	// KMimeApplicationVndExstreamEmpowerZip
	//
	// English:
	//
	//  Application type 'vnd.exstream-empower+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.exstream-empower+zip'
	KMimeApplicationVndExstreamEmpowerZip Mime = "application/vnd.exstream-empower+zip"

	// KMimeApplicationVndExstreamPackage
	//
	// English:
	//
	//  Application type 'vnd.exstream-package'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.exstream-package'
	KMimeApplicationVndExstreamPackage Mime = "application/vnd.exstream-package"

	// KMimeApplicationVndEzpixAlbum
	//
	// English:
	//
	//  Application type 'vnd.ezpix-album'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ezpix-album'
	KMimeApplicationVndEzpixAlbum Mime = "application/vnd.ezpix-album"

	// KMimeApplicationVndEzpixPackage
	//
	// English:
	//
	//  Application type 'vnd.ezpix-package'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ezpix-package'
	KMimeApplicationVndEzpixPackage Mime = "application/vnd.ezpix-package"

	// KMimeApplicationVndFSecureMobile
	//
	// English:
	//
	//  Application type 'vnd.f-secure.mobile'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.f-secure.mobile'
	KMimeApplicationVndFSecureMobile Mime = "application/vnd.f-secure.mobile"

	// KMimeApplicationVndFastcopyDiskImage
	//
	// English:
	//
	//  Application type 'vnd.fastcopy-disk-image'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fastcopy-disk-image'
	KMimeApplicationVndFastcopyDiskImage Mime = "application/vnd.fastcopy-disk-image"

	// KMimeApplicationVndFamilysearchGedcomZip
	//
	// English:
	//
	//  Application type 'vnd.familysearch.gedcom+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.familysearch.gedcom+zip'
	KMimeApplicationVndFamilysearchGedcomZip Mime = "application/vnd.familysearch.gedcom+zip"

	// KMimeApplicationVndFdsnMseed
	//
	// English:
	//
	//  Application type 'vnd.fdsn.mseed'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fdsn.mseed'
	KMimeApplicationVndFdsnMseed Mime = "application/vnd.fdsn.mseed"

	// KMimeApplicationVndFdsnSeed
	//
	// English:
	//
	//  Application type 'vnd.fdsn.seed'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fdsn.seed'
	KMimeApplicationVndFdsnSeed Mime = "application/vnd.fdsn.seed"

	// KMimeApplicationVndFfsns
	//
	// English:
	//
	//  Application type 'vnd.ffsns'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ffsns'
	KMimeApplicationVndFfsns Mime = "application/vnd.ffsns"

	// KMimeApplicationVndFiclabFlbZip
	//
	// English:
	//
	//  Application type 'vnd.ficlab.flb+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ficlab.flb+zip'
	KMimeApplicationVndFiclabFlbZip Mime = "application/vnd.ficlab.flb+zip"

	// KMimeApplicationVndFilmitZfc
	//
	// English:
	//
	//  Application type 'vnd.filmit.zfc'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.filmit.zfc'
	KMimeApplicationVndFilmitZfc Mime = "application/vnd.filmit.zfc"

	// KMimeApplicationVndFints
	//
	// English:
	//
	//  Application type 'vnd.fints'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fints'
	KMimeApplicationVndFints Mime = "application/vnd.fints"

	// KMimeApplicationVndFiremonkeysCloudcell
	//
	// English:
	//
	//  Application type 'vnd.firemonkeys.cloudcell'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.firemonkeys.cloudcell'
	KMimeApplicationVndFiremonkeysCloudcell Mime = "application/vnd.firemonkeys.cloudcell"

	// KMimeApplicationVndFloGraphIt
	//
	// English:
	//
	//  Application type 'vnd.FloGraphIt'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.FloGraphIt'
	KMimeApplicationVndFloGraphIt Mime = "application/vnd.FloGraphIt"

	// KMimeApplicationVndFluxtimeClip
	//
	// English:
	//
	//  Application type 'vnd.fluxtime.clip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fluxtime.clip'
	KMimeApplicationVndFluxtimeClip Mime = "application/vnd.fluxtime.clip"

	// KMimeApplicationVndFontFontforgeSfd
	//
	// English:
	//
	//  Application type 'vnd.font-fontforge-sfd'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.font-fontforge-sfd'
	KMimeApplicationVndFontFontforgeSfd Mime = "application/vnd.font-fontforge-sfd"

	// KMimeApplicationVndFramemaker
	//
	// English:
	//
	//  Application type 'vnd.framemaker'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.framemaker'
	KMimeApplicationVndFramemaker Mime = "application/vnd.framemaker"

	// KMimeApplicationVndFrogansFnc
	//
	// English:
	//
	//  Application type 'vnd.frogans.fnc'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.frogans.fnc'
	KMimeApplicationVndFrogansFnc Mime = "(OBSOLETE)"

	// KMimeApplicationVndFrogansLtf
	//
	// English:
	//
	//  Application type 'vnd.frogans.ltf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.frogans.ltf'
	KMimeApplicationVndFrogansLtf Mime = "(OBSOLETE)"

	// KMimeApplicationVndFscWeblaunch
	//
	// English:
	//
	//  Application type 'vnd.fsc.weblaunch'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fsc.weblaunch'
	KMimeApplicationVndFscWeblaunch Mime = "application/vnd.fsc.weblaunch"

	// KMimeApplicationVndFujifilmFbDocuworks
	//
	// English:
	//
	//  Application type 'vnd.fujifilm.fb.docuworks'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fujifilm.fb.docuworks'
	KMimeApplicationVndFujifilmFbDocuworks Mime = "application/vnd.fujifilm.fb.docuworks"

	// KMimeApplicationVndFujifilmFbDocuworksBinder
	//
	// English:
	//
	//  Application type 'vnd.fujifilm.fb.docuworks.binder'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fujifilm.fb.docuworks.binder'
	KMimeApplicationVndFujifilmFbDocuworksBinder Mime = "application/vnd.fujifilm.fb.docuworks.binder"

	// KMimeApplicationVndFujifilmFbDocuworksContainer
	//
	// English:
	//
	//  Application type 'vnd.fujifilm.fb.docuworks.container'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fujifilm.fb.docuworks.container'
	KMimeApplicationVndFujifilmFbDocuworksContainer Mime = "application/vnd.fujifilm.fb.docuworks.container"

	// KMimeApplicationVndFujifilmFbJfiXml
	//
	// English:
	//
	//  Application type 'vnd.fujifilm.fb.jfi+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fujifilm.fb.jfi+xml'
	KMimeApplicationVndFujifilmFbJfiXml Mime = "application/vnd.fujifilm.fb.jfi+xml"

	// KMimeApplicationVndFujitsuOasys
	//
	// English:
	//
	//  Application type 'vnd.fujitsu.oasys'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fujitsu.oasys'
	KMimeApplicationVndFujitsuOasys Mime = "application/vnd.fujitsu.oasys"

	// KMimeApplicationVndFujitsuOasys2
	//
	// English:
	//
	//  Application type 'vnd.fujitsu.oasys2'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fujitsu.oasys2'
	KMimeApplicationVndFujitsuOasys2 Mime = "application/vnd.fujitsu.oasys2"

	// KMimeApplicationVndFujitsuOasys3
	//
	// English:
	//
	//  Application type 'vnd.fujitsu.oasys3'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fujitsu.oasys3'
	KMimeApplicationVndFujitsuOasys3 Mime = "application/vnd.fujitsu.oasys3"

	// KMimeApplicationVndFujitsuOasysgp
	//
	// English:
	//
	//  Application type 'vnd.fujitsu.oasysgp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fujitsu.oasysgp'
	KMimeApplicationVndFujitsuOasysgp Mime = "application/vnd.fujitsu.oasysgp"

	// KMimeApplicationVndFujitsuOasysprs
	//
	// English:
	//
	//  Application type 'vnd.fujitsu.oasysprs'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fujitsu.oasysprs'
	KMimeApplicationVndFujitsuOasysprs Mime = "application/vnd.fujitsu.oasysprs"

	// KMimeApplicationVndFujixeroxART4
	//
	// English:
	//
	//  Application type 'vnd.fujixerox.ART4'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fujixerox.ART4'
	KMimeApplicationVndFujixeroxART4 Mime = "application/vnd.fujixerox.ART4"

	// KMimeApplicationVndFujixeroxARTEX
	//
	// English:
	//
	//  Application type 'vnd.fujixerox.ART-EX'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fujixerox.ART-EX'
	KMimeApplicationVndFujixeroxARTEX Mime = "application/vnd.fujixerox.ART-EX"

	// KMimeApplicationVndFujixeroxDdd
	//
	// English:
	//
	//  Application type 'vnd.fujixerox.ddd'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fujixerox.ddd'
	KMimeApplicationVndFujixeroxDdd Mime = "application/vnd.fujixerox.ddd"

	// KMimeApplicationVndFujixeroxDocuworks
	//
	// English:
	//
	//  Application type 'vnd.fujixerox.docuworks'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fujixerox.docuworks'
	KMimeApplicationVndFujixeroxDocuworks Mime = "application/vnd.fujixerox.docuworks"

	// KMimeApplicationVndFujixeroxDocuworksBinder
	//
	// English:
	//
	//  Application type 'vnd.fujixerox.docuworks.binder'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fujixerox.docuworks.binder'
	KMimeApplicationVndFujixeroxDocuworksBinder Mime = "application/vnd.fujixerox.docuworks.binder"

	// KMimeApplicationVndFujixeroxDocuworksContainer
	//
	// English:
	//
	//  Application type 'vnd.fujixerox.docuworks.container'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fujixerox.docuworks.container'
	KMimeApplicationVndFujixeroxDocuworksContainer Mime = "application/vnd.fujixerox.docuworks.container"

	// KMimeApplicationVndFujixeroxHBPL
	//
	// English:
	//
	//  Application type 'vnd.fujixerox.HBPL'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fujixerox.HBPL'
	KMimeApplicationVndFujixeroxHBPL Mime = "application/vnd.fujixerox.HBPL"

	// KMimeApplicationVndFutMisnet
	//
	// English:
	//
	//  Application type 'vnd.fut-misnet'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fut-misnet'
	KMimeApplicationVndFutMisnet Mime = "application/vnd.fut-misnet"

	// KMimeApplicationVndFutoinCbor
	//
	// English:
	//
	//  Application type 'vnd.futoin+cbor'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.futoin+cbor'
	KMimeApplicationVndFutoinCbor Mime = "application/vnd.futoin+cbor"

	// KMimeApplicationVndFutoinJson
	//
	// English:
	//
	//  Application type 'vnd.futoin+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.futoin+json'
	KMimeApplicationVndFutoinJson Mime = "application/vnd.futoin+json"

	// KMimeApplicationVndFuzzysheet
	//
	// English:
	//
	//  Application type 'vnd.fuzzysheet'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fuzzysheet'
	KMimeApplicationVndFuzzysheet Mime = "application/vnd.fuzzysheet"

	// KMimeApplicationVndGenomatixTuxedo
	//
	// English:
	//
	//  Application type 'vnd.genomatix.tuxedo'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.genomatix.tuxedo'
	KMimeApplicationVndGenomatixTuxedo Mime = "application/vnd.genomatix.tuxedo"

	// KMimeApplicationVndGenozip
	//
	// English:
	//
	//  Application type 'vnd.genozip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.genozip'
	KMimeApplicationVndGenozip Mime = "application/vnd.genozip"

	// KMimeApplicationVndGenticsGrdJson
	//
	// English:
	//
	//  Application type 'vnd.gentics.grd+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.gentics.grd+json'
	KMimeApplicationVndGenticsGrdJson Mime = "application/vnd.gentics.grd+json"

	// KMimeApplicationVndGeoJson
	//
	// English:
	//
	//  Application type 'vnd.geo+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.geo+json'
	KMimeApplicationVndGeoJson Mime = "(OBSOLETED"

	// KMimeApplicationVndGeocubeXml
	//
	// English:
	//
	//  Application type 'vnd.geocube+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.geocube+xml'
	KMimeApplicationVndGeocubeXml Mime = "(OBSOLETED"

	// KMimeApplicationVndGeogebraFile
	//
	// English:
	//
	//  Application type 'vnd.geogebra.file'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.geogebra.file'
	KMimeApplicationVndGeogebraFile Mime = "application/vnd.geogebra.file"

	// KMimeApplicationVndGeogebraSlides
	//
	// English:
	//
	//  Application type 'vnd.geogebra.slides'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.geogebra.slides'
	KMimeApplicationVndGeogebraSlides Mime = "application/vnd.geogebra.slides"

	// KMimeApplicationVndGeogebraTool
	//
	// English:
	//
	//  Application type 'vnd.geogebra.tool'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.geogebra.tool'
	KMimeApplicationVndGeogebraTool Mime = "application/vnd.geogebra.tool"

	// KMimeApplicationVndGeometryExplorer
	//
	// English:
	//
	//  Application type 'vnd.geometry-explorer'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.geometry-explorer'
	KMimeApplicationVndGeometryExplorer Mime = "application/vnd.geometry-explorer"

	// KMimeApplicationVndGeonext
	//
	// English:
	//
	//  Application type 'vnd.geonext'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.geonext'
	KMimeApplicationVndGeonext Mime = "application/vnd.geonext"

	// KMimeApplicationVndGeoplan
	//
	// English:
	//
	//  Application type 'vnd.geoplan'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.geoplan'
	KMimeApplicationVndGeoplan Mime = "application/vnd.geoplan"

	// KMimeApplicationVndGeospace
	//
	// English:
	//
	//  Application type 'vnd.geospace'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.geospace'
	KMimeApplicationVndGeospace Mime = "application/vnd.geospace"

	// KMimeApplicationVndGerber
	//
	// English:
	//
	//  Application type 'vnd.gerber'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.gerber'
	KMimeApplicationVndGerber Mime = "application/vnd.gerber"

	// KMimeApplicationVndGlobalplatformCardContentMgt
	//
	// English:
	//
	//  Application type 'vnd.globalplatform.card-content-mgt'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.globalplatform.card-content-mgt'
	KMimeApplicationVndGlobalplatformCardContentMgt Mime = "application/vnd.globalplatform.card-content-mgt"

	// KMimeApplicationVndGlobalplatformCardContentMgtResponse
	//
	// English:
	//
	//  Application type 'vnd.globalplatform.card-content-mgt-response'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.globalplatform.card-content-mgt-response'
	KMimeApplicationVndGlobalplatformCardContentMgtResponse Mime = "application/vnd.globalplatform.card-content-mgt-response"

	// KMimeApplicationVndGmx
	//
	// English:
	//
	//  Application type 'vnd.gmx'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.gmx'
	KMimeApplicationVndGmx Mime = "-"

	// KMimeApplicationVndGnuTalerExchangeJson
	//
	// English:
	//
	//  Application type 'vnd.gnu.taler.exchange+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.gnu.taler.exchange+json'
	KMimeApplicationVndGnuTalerExchangeJson Mime = "application/vnd.gnu.taler.exchange+json"

	// KMimeApplicationVndGnuTalerMerchantJson
	//
	// English:
	//
	//  Application type 'vnd.gnu.taler.merchant+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.gnu.taler.merchant+json'
	KMimeApplicationVndGnuTalerMerchantJson Mime = "application/vnd.gnu.taler.merchant+json"

	// KMimeApplicationVndGoogleEarthKmlXml
	//
	// English:
	//
	//  Application type 'vnd.google-earth.kml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.google-earth.kml+xml'
	KMimeApplicationVndGoogleEarthKmlXml Mime = "application/vnd.google-earth.kml+xml"

	// KMimeApplicationVndGoogleEarthKmz
	//
	// English:
	//
	//  Application type 'vnd.google-earth.kmz'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.google-earth.kmz'
	KMimeApplicationVndGoogleEarthKmz Mime = "application/vnd.google-earth.kmz"

	// KMimeApplicationVndGovSkEFormXml
	//
	// English:
	//
	//  Application type 'vnd.gov.sk.e-form+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.gov.sk.e-form+xml'
	KMimeApplicationVndGovSkEFormXml Mime = "application/vnd.gov.sk.e-form+xml"

	// KMimeApplicationVndGovSkEFormZip
	//
	// English:
	//
	//  Application type 'vnd.gov.sk.e-form+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.gov.sk.e-form+zip'
	KMimeApplicationVndGovSkEFormZip Mime = "application/vnd.gov.sk.e-form+zip"

	// KMimeApplicationVndGovSkXmldatacontainerXml
	//
	// English:
	//
	//  Application type 'vnd.gov.sk.xmldatacontainer+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.gov.sk.xmldatacontainer+xml'
	KMimeApplicationVndGovSkXmldatacontainerXml Mime = "application/vnd.gov.sk.xmldatacontainer+xml"

	// KMimeApplicationVndGrafeq
	//
	// English:
	//
	//  Application type 'vnd.grafeq'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.grafeq'
	KMimeApplicationVndGrafeq Mime = "application/vnd.grafeq"

	// KMimeApplicationVndGridmp
	//
	// English:
	//
	//  Application type 'vnd.gridmp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.gridmp'
	KMimeApplicationVndGridmp Mime = "application/vnd.gridmp"

	// KMimeApplicationVndGrooveAccount
	//
	// English:
	//
	//  Application type 'vnd.groove-account'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.groove-account'
	KMimeApplicationVndGrooveAccount Mime = "application/vnd.groove-account"

	// KMimeApplicationVndGrooveHelp
	//
	// English:
	//
	//  Application type 'vnd.groove-help'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.groove-help'
	KMimeApplicationVndGrooveHelp Mime = "application/vnd.groove-help"

	// KMimeApplicationVndGrooveIdentityMessage
	//
	// English:
	//
	//  Application type 'vnd.groove-identity-message'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.groove-identity-message'
	KMimeApplicationVndGrooveIdentityMessage Mime = "application/vnd.groove-identity-message"

	// KMimeApplicationVndGrooveInjector
	//
	// English:
	//
	//  Application type 'vnd.groove-injector'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.groove-injector'
	KMimeApplicationVndGrooveInjector Mime = "application/vnd.groove-injector"

	// KMimeApplicationVndGrooveToolMessage
	//
	// English:
	//
	//  Application type 'vnd.groove-tool-message'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.groove-tool-message'
	KMimeApplicationVndGrooveToolMessage Mime = "application/vnd.groove-tool-message"

	// KMimeApplicationVndGrooveToolTemplate
	//
	// English:
	//
	//  Application type 'vnd.groove-tool-template'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.groove-tool-template'
	KMimeApplicationVndGrooveToolTemplate Mime = "application/vnd.groove-tool-template"

	// KMimeApplicationVndGrooveVcard
	//
	// English:
	//
	//  Application type 'vnd.groove-vcard'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.groove-vcard'
	KMimeApplicationVndGrooveVcard Mime = "application/vnd.groove-vcard"

	// KMimeApplicationVndHalJson
	//
	// English:
	//
	//  Application type 'vnd.hal+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hal+json'
	KMimeApplicationVndHalJson Mime = "application/vnd.hal+json"

	// KMimeApplicationVndHalXml
	//
	// English:
	//
	//  Application type 'vnd.hal+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hal+xml'
	KMimeApplicationVndHalXml Mime = "application/vnd.hal+xml"

	// KMimeApplicationVndHandHeldEntertainmentXml
	//
	// English:
	//
	//  Application type 'vnd.HandHeld-Entertainment+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.HandHeld-Entertainment+xml'
	KMimeApplicationVndHandHeldEntertainmentXml Mime = "application/vnd.HandHeld-Entertainment+xml"

	// KMimeApplicationVndHbci
	//
	// English:
	//
	//  Application type 'vnd.hbci'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hbci'
	KMimeApplicationVndHbci Mime = "application/vnd.hbci"

	// KMimeApplicationVndHcJson
	//
	// English:
	//
	//  Application type 'vnd.hc+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hc+json'
	KMimeApplicationVndHcJson Mime = "application/vnd.hc+json"

	// KMimeApplicationVndHclBireports
	//
	// English:
	//
	//  Application type 'vnd.hcl-bireports'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hcl-bireports'
	KMimeApplicationVndHclBireports Mime = "application/vnd.hcl-bireports"

	// KMimeApplicationVndHdt
	//
	// English:
	//
	//  Application type 'vnd.hdt'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hdt'
	KMimeApplicationVndHdt Mime = "application/vnd.hdt"

	// KMimeApplicationVndHerokuJson
	//
	// English:
	//
	//  Application type 'vnd.heroku+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.heroku+json'
	KMimeApplicationVndHerokuJson Mime = "application/vnd.heroku+json"

	// KMimeApplicationVndHheLessonPlayer
	//
	// English:
	//
	//  Application type 'vnd.hhe.lesson-player'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hhe.lesson-player'
	KMimeApplicationVndHheLessonPlayer Mime = "application/vnd.hhe.lesson-player"

	// KMimeApplicationVndHpHPGL
	//
	// English:
	//
	//  Application type 'vnd.hp-HPGL'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hp-HPGL'
	KMimeApplicationVndHpHPGL Mime = "application/vnd.hp-HPGL"

	// KMimeApplicationVndHpHpid
	//
	// English:
	//
	//  Application type 'vnd.hp-hpid'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hp-hpid'
	KMimeApplicationVndHpHpid Mime = "application/vnd.hp-hpid"

	// KMimeApplicationVndHpHps
	//
	// English:
	//
	//  Application type 'vnd.hp-hps'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hp-hps'
	KMimeApplicationVndHpHps Mime = "application/vnd.hp-hps"

	// KMimeApplicationVndHpJlyt
	//
	// English:
	//
	//  Application type 'vnd.hp-jlyt'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hp-jlyt'
	KMimeApplicationVndHpJlyt Mime = "application/vnd.hp-jlyt"

	// KMimeApplicationVndHpPCL
	//
	// English:
	//
	//  Application type 'vnd.hp-PCL'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hp-PCL'
	KMimeApplicationVndHpPCL Mime = "application/vnd.hp-PCL"

	// KMimeApplicationVndHpPCLXL
	//
	// English:
	//
	//  Application type 'vnd.hp-PCLXL'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hp-PCLXL'
	KMimeApplicationVndHpPCLXL Mime = "application/vnd.hp-PCLXL"

	// KMimeApplicationVndHttphone
	//
	// English:
	//
	//  Application type 'vnd.httphone'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.httphone'
	KMimeApplicationVndHttphone Mime = "application/vnd.httphone"

	// KMimeApplicationVndHydrostatixSofData
	//
	// English:
	//
	//  Application type 'vnd.hydrostatix.sof-data'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hydrostatix.sof-data'
	KMimeApplicationVndHydrostatixSofData Mime = "application/vnd.hydrostatix.sof-data"

	// KMimeApplicationVndHyperItemJson
	//
	// English:
	//
	//  Application type 'vnd.hyper-item+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hyper-item+json'
	KMimeApplicationVndHyperItemJson Mime = "application/vnd.hyper-item+json"

	// KMimeApplicationVndHyperJson
	//
	// English:
	//
	//  Application type 'vnd.hyper+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hyper+json'
	KMimeApplicationVndHyperJson Mime = "application/vnd.hyper+json"

	// KMimeApplicationVndHyperdriveJson
	//
	// English:
	//
	//  Application type 'vnd.hyperdrive+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hyperdrive+json'
	KMimeApplicationVndHyperdriveJson Mime = "application/vnd.hyperdrive+json"

	// KMimeApplicationVndHzn3dCrossword
	//
	// English:
	//
	//  Application type 'vnd.hzn-3d-crossword'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hzn-3d-crossword'
	KMimeApplicationVndHzn3dCrossword Mime = "application/vnd.hzn-3d-crossword"

	// KMimeApplicationVndIbmAfplinedata
	//
	// English:
	//
	//  Application type 'vnd.ibm.afplinedata'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ibm.afplinedata'
	KMimeApplicationVndIbmAfplinedata Mime = "(OBSOLETED"

	// KMimeApplicationVndIbmElectronicMedia
	//
	// English:
	//
	//  Application type 'vnd.ibm.electronic-media'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ibm.electronic-media'
	KMimeApplicationVndIbmElectronicMedia Mime = "application/vnd.ibm.electronic-media"

	// KMimeApplicationVndIbmMiniPay
	//
	// English:
	//
	//  Application type 'vnd.ibm.MiniPay'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ibm.MiniPay'
	KMimeApplicationVndIbmMiniPay Mime = "application/vnd.ibm.MiniPay"

	// KMimeApplicationVndIbmModcap
	//
	// English:
	//
	//  Application type 'vnd.ibm.modcap'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ibm.modcap'
	KMimeApplicationVndIbmModcap Mime = "(OBSOLETED"

	// KMimeApplicationVndIbmRightsManagement
	//
	// English:
	//
	//  Application type 'vnd.ibm.rights-management'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ibm.rights-management'
	KMimeApplicationVndIbmRightsManagement Mime = "application/vnd.ibm.rights-management"

	// KMimeApplicationVndIbmSecureContainer
	//
	// English:
	//
	//  Application type 'vnd.ibm.secure-container'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ibm.secure-container'
	KMimeApplicationVndIbmSecureContainer Mime = "application/vnd.ibm.secure-container"

	// KMimeApplicationVndIccprofile
	//
	// English:
	//
	//  Application type 'vnd.iccprofile'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.iccprofile'
	KMimeApplicationVndIccprofile Mime = "application/vnd.iccprofile"

	// KMimeApplicationVndIeee1905
	//
	// English:
	//
	//  Application type 'vnd.ieee.1905'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ieee.1905'
	KMimeApplicationVndIeee1905 Mime = "application/vnd.ieee.1905"

	// KMimeApplicationVndIgloader
	//
	// English:
	//
	//  Application type 'vnd.igloader'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.igloader'
	KMimeApplicationVndIgloader Mime = "application/vnd.igloader"

	// KMimeApplicationVndImagemeterFolderZip
	//
	// English:
	//
	//  Application type 'vnd.imagemeter.folder+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.imagemeter.folder+zip'
	KMimeApplicationVndImagemeterFolderZip Mime = "application/vnd.imagemeter.folder+zip"

	// KMimeApplicationVndImagemeterImageZip
	//
	// English:
	//
	//  Application type 'vnd.imagemeter.image+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.imagemeter.image+zip'
	KMimeApplicationVndImagemeterImageZip Mime = "application/vnd.imagemeter.image+zip"

	// KMimeApplicationVndImmervisionIvp
	//
	// English:
	//
	//  Application type 'vnd.immervision-ivp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.immervision-ivp'
	KMimeApplicationVndImmervisionIvp Mime = "application/vnd.immervision-ivp"

	// KMimeApplicationVndImmervisionIvu
	//
	// English:
	//
	//  Application type 'vnd.immervision-ivu'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.immervision-ivu'
	KMimeApplicationVndImmervisionIvu Mime = "application/vnd.immervision-ivu"

	// KMimeApplicationVndImsImsccv1p1
	//
	// English:
	//
	//  Application type 'vnd.ims.imsccv1p1'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ims.imsccv1p1'
	KMimeApplicationVndImsImsccv1p1 Mime = "application/vnd.ims.imsccv1p1"

	// KMimeApplicationVndImsImsccv1p2
	//
	// English:
	//
	//  Application type 'vnd.ims.imsccv1p2'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ims.imsccv1p2'
	KMimeApplicationVndImsImsccv1p2 Mime = "application/vnd.ims.imsccv1p2"

	// KMimeApplicationVndImsImsccv1p3
	//
	// English:
	//
	//  Application type 'vnd.ims.imsccv1p3'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ims.imsccv1p3'
	KMimeApplicationVndImsImsccv1p3 Mime = "application/vnd.ims.imsccv1p3"

	// KMimeApplicationVndImsLisV2ResultJson
	//
	// English:
	//
	//  Application type 'vnd.ims.lis.v2.result+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ims.lis.v2.result+json'
	KMimeApplicationVndImsLisV2ResultJson Mime = "application/vnd.ims.lis.v2.result+json"

	// KMimeApplicationVndImsLtiV2ToolconsumerprofileJson
	//
	// English:
	//
	//  Application type 'vnd.ims.lti.v2.toolconsumerprofile+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ims.lti.v2.toolconsumerprofile+json'
	KMimeApplicationVndImsLtiV2ToolconsumerprofileJson Mime = "application/vnd.ims.lti.v2.toolconsumerprofile+json"

	// KMimeApplicationVndImsLtiV2ToolproxyIdJson
	//
	// English:
	//
	//  Application type 'vnd.ims.lti.v2.toolproxy.id+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ims.lti.v2.toolproxy.id+json'
	KMimeApplicationVndImsLtiV2ToolproxyIdJson Mime = "application/vnd.ims.lti.v2.toolproxy.id+json"

	// KMimeApplicationVndImsLtiV2ToolproxyJson
	//
	// English:
	//
	//  Application type 'vnd.ims.lti.v2.toolproxy+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ims.lti.v2.toolproxy+json'
	KMimeApplicationVndImsLtiV2ToolproxyJson Mime = "application/vnd.ims.lti.v2.toolproxy+json"

	// KMimeApplicationVndImsLtiV2ToolsettingsJson
	//
	// English:
	//
	//  Application type 'vnd.ims.lti.v2.toolsettings+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ims.lti.v2.toolsettings+json'
	KMimeApplicationVndImsLtiV2ToolsettingsJson Mime = "application/vnd.ims.lti.v2.toolsettings+json"

	// KMimeApplicationVndImsLtiV2ToolsettingsSimpleJson
	//
	// English:
	//
	//  Application type 'vnd.ims.lti.v2.toolsettings.simple+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ims.lti.v2.toolsettings.simple+json'
	KMimeApplicationVndImsLtiV2ToolsettingsSimpleJson Mime = "application/vnd.ims.lti.v2.toolsettings.simple+json"

	// KMimeApplicationVndInformedcontrolRmsXml
	//
	// English:
	//
	//  Application type 'vnd.informedcontrol.rms+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.informedcontrol.rms+xml'
	KMimeApplicationVndInformedcontrolRmsXml Mime = "application/vnd.informedcontrol.rms+xml"

	// KMimeApplicationVndInfotechProject
	//
	// English:
	//
	//  Application type 'vnd.infotech.project'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.infotech.project'
	KMimeApplicationVndInfotechProject Mime = "application/vnd.infotech.project"

	// KMimeApplicationVndInfotechProjectXml
	//
	// English:
	//
	//  Application type 'vnd.infotech.project+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.infotech.project+xml'
	KMimeApplicationVndInfotechProjectXml Mime = "application/vnd.infotech.project+xml"

	// KMimeApplicationVndInformixVisionary
	//
	// English:
	//
	//  Application type 'vnd.informix-visionary'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.informix-visionary'
	KMimeApplicationVndInformixVisionary Mime = "(OBSOLETED"

	// KMimeApplicationVndInnopathWampNotification
	//
	// English:
	//
	//  Application type 'vnd.innopath.wamp.notification'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.innopath.wamp.notification'
	KMimeApplicationVndInnopathWampNotification Mime = "application/vnd.innopath.wamp.notification"

	// KMimeApplicationVndInsorsIgm
	//
	// English:
	//
	//  Application type 'vnd.insors.igm'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.insors.igm'
	KMimeApplicationVndInsorsIgm Mime = "application/vnd.insors.igm"

	// KMimeApplicationVndInterconFormnet
	//
	// English:
	//
	//  Application type 'vnd.intercon.formnet'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.intercon.formnet'
	KMimeApplicationVndInterconFormnet Mime = "application/vnd.intercon.formnet"

	// KMimeApplicationVndIntergeo
	//
	// English:
	//
	//  Application type 'vnd.intergeo'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.intergeo'
	KMimeApplicationVndIntergeo Mime = "application/vnd.intergeo"

	// KMimeApplicationVndIntertrustDigibox
	//
	// English:
	//
	//  Application type 'vnd.intertrust.digibox'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.intertrust.digibox'
	KMimeApplicationVndIntertrustDigibox Mime = "application/vnd.intertrust.digibox"

	// KMimeApplicationVndIntertrustNncp
	//
	// English:
	//
	//  Application type 'vnd.intertrust.nncp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.intertrust.nncp'
	KMimeApplicationVndIntertrustNncp Mime = "application/vnd.intertrust.nncp"

	// KMimeApplicationVndIntuQbo
	//
	// English:
	//
	//  Application type 'vnd.intu.qbo'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.intu.qbo'
	KMimeApplicationVndIntuQbo Mime = "application/vnd.intu.qbo"

	// KMimeApplicationVndIntuQfx
	//
	// English:
	//
	//  Application type 'vnd.intu.qfx'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.intu.qfx'
	KMimeApplicationVndIntuQfx Mime = "application/vnd.intu.qfx"

	// KMimeApplicationVndIpldCar
	//
	// English:
	//
	//  Application type 'vnd.ipld.car'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ipld.car'
	KMimeApplicationVndIpldCar Mime = "application/vnd.ipld.car"

	// KMimeApplicationVndIpldRaw
	//
	// English:
	//
	//  Application type 'vnd.ipld.raw'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ipld.raw'
	KMimeApplicationVndIpldRaw Mime = "application/vnd.ipld.raw"

	// KMimeApplicationVndIptcG2CatalogitemXml
	//
	// English:
	//
	//  Application type 'vnd.iptc.g2.catalogitem+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.iptc.g2.catalogitem+xml'
	KMimeApplicationVndIptcG2CatalogitemXml Mime = "application/vnd.iptc.g2.catalogitem+xml"

	// KMimeApplicationVndIptcG2ConceptitemXml
	//
	// English:
	//
	//  Application type 'vnd.iptc.g2.conceptitem+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.iptc.g2.conceptitem+xml'
	KMimeApplicationVndIptcG2ConceptitemXml Mime = "application/vnd.iptc.g2.conceptitem+xml"

	// KMimeApplicationVndIptcG2KnowledgeitemXml
	//
	// English:
	//
	//  Application type 'vnd.iptc.g2.knowledgeitem+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.iptc.g2.knowledgeitem+xml'
	KMimeApplicationVndIptcG2KnowledgeitemXml Mime = "application/vnd.iptc.g2.knowledgeitem+xml"

	// KMimeApplicationVndIptcG2NewsitemXml
	//
	// English:
	//
	//  Application type 'vnd.iptc.g2.newsitem+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.iptc.g2.newsitem+xml'
	KMimeApplicationVndIptcG2NewsitemXml Mime = "application/vnd.iptc.g2.newsitem+xml"

	// KMimeApplicationVndIptcG2NewsmessageXml
	//
	// English:
	//
	//  Application type 'vnd.iptc.g2.newsmessage+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.iptc.g2.newsmessage+xml'
	KMimeApplicationVndIptcG2NewsmessageXml Mime = "application/vnd.iptc.g2.newsmessage+xml"

	// KMimeApplicationVndIptcG2PackageitemXml
	//
	// English:
	//
	//  Application type 'vnd.iptc.g2.packageitem+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.iptc.g2.packageitem+xml'
	KMimeApplicationVndIptcG2PackageitemXml Mime = "application/vnd.iptc.g2.packageitem+xml"

	// KMimeApplicationVndIptcG2PlanningitemXml
	//
	// English:
	//
	//  Application type 'vnd.iptc.g2.planningitem+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.iptc.g2.planningitem+xml'
	KMimeApplicationVndIptcG2PlanningitemXml Mime = "application/vnd.iptc.g2.planningitem+xml"

	// KMimeApplicationVndIpunpluggedRcprofile
	//
	// English:
	//
	//  Application type 'vnd.ipunplugged.rcprofile'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ipunplugged.rcprofile'
	KMimeApplicationVndIpunpluggedRcprofile Mime = "application/vnd.ipunplugged.rcprofile"

	// KMimeApplicationVndIrepositoryPackageXml
	//
	// English:
	//
	//  Application type 'vnd.irepository.package+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.irepository.package+xml'
	KMimeApplicationVndIrepositoryPackageXml Mime = "application/vnd.irepository.package+xml"

	// KMimeApplicationVndIsXpr
	//
	// English:
	//
	//  Application type 'vnd.is-xpr'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.is-xpr'
	KMimeApplicationVndIsXpr Mime = "application/vnd.is-xpr"

	// KMimeApplicationVndIsacFcs
	//
	// English:
	//
	//  Application type 'vnd.isac.fcs'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.isac.fcs'
	KMimeApplicationVndIsacFcs Mime = "application/vnd.isac.fcs"

	// KMimeApplicationVndJam
	//
	// English:
	//
	//  Application type 'vnd.jam'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.jam'
	KMimeApplicationVndJam Mime = "application/vnd.jam"

	// KMimeApplicationVndIso1178310Zip
	//
	// English:
	//
	//  Application type 'vnd.iso11783-10+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.iso11783-10+zip'
	KMimeApplicationVndIso1178310Zip Mime = "application/vnd.iso11783-10+zip"

	// KMimeApplicationVndJapannetDirectoryService
	//
	// English:
	//
	//  Application type 'vnd.japannet-directory-service'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.japannet-directory-service'
	KMimeApplicationVndJapannetDirectoryService Mime = "application/vnd.japannet-directory-service"

	// KMimeApplicationVndJapannetJpnstoreWakeup
	//
	// English:
	//
	//  Application type 'vnd.japannet-jpnstore-wakeup'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.japannet-jpnstore-wakeup'
	KMimeApplicationVndJapannetJpnstoreWakeup Mime = "application/vnd.japannet-jpnstore-wakeup"

	// KMimeApplicationVndJapannetPaymentWakeup
	//
	// English:
	//
	//  Application type 'vnd.japannet-payment-wakeup'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.japannet-payment-wakeup'
	KMimeApplicationVndJapannetPaymentWakeup Mime = "application/vnd.japannet-payment-wakeup"

	// KMimeApplicationVndJapannetRegistration
	//
	// English:
	//
	//  Application type 'vnd.japannet-registration'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.japannet-registration'
	KMimeApplicationVndJapannetRegistration Mime = "application/vnd.japannet-registration"

	// KMimeApplicationVndJapannetRegistrationWakeup
	//
	// English:
	//
	//  Application type 'vnd.japannet-registration-wakeup'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.japannet-registration-wakeup'
	KMimeApplicationVndJapannetRegistrationWakeup Mime = "application/vnd.japannet-registration-wakeup"

	// KMimeApplicationVndJapannetSetstoreWakeup
	//
	// English:
	//
	//  Application type 'vnd.japannet-setstore-wakeup'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.japannet-setstore-wakeup'
	KMimeApplicationVndJapannetSetstoreWakeup Mime = "application/vnd.japannet-setstore-wakeup"

	// KMimeApplicationVndJapannetVerification
	//
	// English:
	//
	//  Application type 'vnd.japannet-verification'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.japannet-verification'
	KMimeApplicationVndJapannetVerification Mime = "application/vnd.japannet-verification"

	// KMimeApplicationVndJapannetVerificationWakeup
	//
	// English:
	//
	//  Application type 'vnd.japannet-verification-wakeup'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.japannet-verification-wakeup'
	KMimeApplicationVndJapannetVerificationWakeup Mime = "application/vnd.japannet-verification-wakeup"

	// KMimeApplicationVndJcpJavameMidletRms
	//
	// English:
	//
	//  Application type 'vnd.jcp.javame.midlet-rms'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.jcp.javame.midlet-rms'
	KMimeApplicationVndJcpJavameMidletRms Mime = "application/vnd.jcp.javame.midlet-rms"

	// KMimeApplicationVndJisp
	//
	// English:
	//
	//  Application type 'vnd.jisp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.jisp'
	KMimeApplicationVndJisp Mime = "application/vnd.jisp"

	// KMimeApplicationVndJoostJodaArchive
	//
	// English:
	//
	//  Application type 'vnd.joost.joda-archive'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.joost.joda-archive'
	KMimeApplicationVndJoostJodaArchive Mime = "application/vnd.joost.joda-archive"

	// KMimeApplicationVndJskIsdnNgn
	//
	// English:
	//
	//  Application type 'vnd.jsk.isdn-ngn'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.jsk.isdn-ngn'
	KMimeApplicationVndJskIsdnNgn Mime = "application/vnd.jsk.isdn-ngn"

	// KMimeApplicationVndKahootz
	//
	// English:
	//
	//  Application type 'vnd.kahootz'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.kahootz'
	KMimeApplicationVndKahootz Mime = "application/vnd.kahootz"

	// KMimeApplicationVndKdeKarbon
	//
	// English:
	//
	//  Application type 'vnd.kde.karbon'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.kde.karbon'
	KMimeApplicationVndKdeKarbon Mime = "application/vnd.kde.karbon"

	// KMimeApplicationVndKdeKchart
	//
	// English:
	//
	//  Application type 'vnd.kde.kchart'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.kde.kchart'
	KMimeApplicationVndKdeKchart Mime = "application/vnd.kde.kchart"

	// KMimeApplicationVndKdeKformula
	//
	// English:
	//
	//  Application type 'vnd.kde.kformula'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.kde.kformula'
	KMimeApplicationVndKdeKformula Mime = "application/vnd.kde.kformula"

	// KMimeApplicationVndKdeKivio
	//
	// English:
	//
	//  Application type 'vnd.kde.kivio'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.kde.kivio'
	KMimeApplicationVndKdeKivio Mime = "application/vnd.kde.kivio"

	// KMimeApplicationVndKdeKontour
	//
	// English:
	//
	//  Application type 'vnd.kde.kontour'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.kde.kontour'
	KMimeApplicationVndKdeKontour Mime = "application/vnd.kde.kontour"

	// KMimeApplicationVndKdeKpresenter
	//
	// English:
	//
	//  Application type 'vnd.kde.kpresenter'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.kde.kpresenter'
	KMimeApplicationVndKdeKpresenter Mime = "application/vnd.kde.kpresenter"

	// KMimeApplicationVndKdeKspread
	//
	// English:
	//
	//  Application type 'vnd.kde.kspread'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.kde.kspread'
	KMimeApplicationVndKdeKspread Mime = "application/vnd.kde.kspread"

	// KMimeApplicationVndKdeKword
	//
	// English:
	//
	//  Application type 'vnd.kde.kword'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.kde.kword'
	KMimeApplicationVndKdeKword Mime = "application/vnd.kde.kword"

	// KMimeApplicationVndKenameaapp
	//
	// English:
	//
	//  Application type 'vnd.kenameaapp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.kenameaapp'
	KMimeApplicationVndKenameaapp Mime = "application/vnd.kenameaapp"

	// KMimeApplicationVndKidspiration
	//
	// English:
	//
	//  Application type 'vnd.kidspiration'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.kidspiration'
	KMimeApplicationVndKidspiration Mime = "application/vnd.kidspiration"

	// KMimeApplicationVndKinar
	//
	// English:
	//
	//  Application type 'vnd.Kinar'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.Kinar'
	KMimeApplicationVndKinar Mime = "application/vnd.Kinar"

	// KMimeApplicationVndKoan
	//
	// English:
	//
	//  Application type 'vnd.koan'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.koan'
	KMimeApplicationVndKoan Mime = "application/vnd.koan"

	// KMimeApplicationVndKodakDescriptor
	//
	// English:
	//
	//  Application type 'vnd.kodak-descriptor'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.kodak-descriptor'
	KMimeApplicationVndKodakDescriptor Mime = "application/vnd.kodak-descriptor"

	// KMimeApplicationVndLas
	//
	// English:
	//
	//  Application type 'vnd.las'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.las'
	KMimeApplicationVndLas Mime = "application/vnd.las"

	// KMimeApplicationVndLasLasJson
	//
	// English:
	//
	//  Application type 'vnd.las.las+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.las.las+json'
	KMimeApplicationVndLasLasJson Mime = "application/vnd.las.las+json"

	// KMimeApplicationVndLasLasXml
	//
	// English:
	//
	//  Application type 'vnd.las.las+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.las.las+xml'
	KMimeApplicationVndLasLasXml Mime = "application/vnd.las.las+xml"

	// KMimeApplicationVndLaszip
	//
	// English:
	//
	//  Application type 'vnd.laszip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.laszip'
	KMimeApplicationVndLaszip Mime = "application/vnd.laszip"

	// KMimeApplicationVndLeapJson
	//
	// English:
	//
	//  Application type 'vnd.leap+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.leap+json'
	KMimeApplicationVndLeapJson Mime = "application/vnd.leap+json"

	// KMimeApplicationVndLibertyRequestXml
	//
	// English:
	//
	//  Application type 'vnd.liberty-request+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.liberty-request+xml'
	KMimeApplicationVndLibertyRequestXml Mime = "application/vnd.liberty-request+xml"

	// KMimeApplicationVndLlamagraphicsLifeBalanceDesktop
	//
	// English:
	//
	//  Application type 'vnd.llamagraphics.life-balance.desktop'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.llamagraphics.life-balance.desktop'
	KMimeApplicationVndLlamagraphicsLifeBalanceDesktop Mime = "application/vnd.llamagraphics.life-balance.desktop"

	// KMimeApplicationVndLlamagraphicsLifeBalanceExchangeXml
	//
	// English:
	//
	//  Application type 'vnd.llamagraphics.life-balance.exchange+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.llamagraphics.life-balance.exchange+xml'
	KMimeApplicationVndLlamagraphicsLifeBalanceExchangeXml Mime = "application/vnd.llamagraphics.life-balance.exchange+xml"

	// KMimeApplicationVndLogipipeCircuitZip
	//
	// English:
	//
	//  Application type 'vnd.logipipe.circuit+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.logipipe.circuit+zip'
	KMimeApplicationVndLogipipeCircuitZip Mime = "application/vnd.logipipe.circuit+zip"

	// KMimeApplicationVndLoom
	//
	// English:
	//
	//  Application type 'vnd.loom'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.loom'
	KMimeApplicationVndLoom Mime = "application/vnd.loom"

	// KMimeApplicationVndLotus_1_2_3`
	//
	// English:
	//
	//  Application type 'vnd.lotus-1-2-3'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.lotus-1-2-3'
	KMimeApplicationVndLotus_1_2_3 Mime = "application/vnd.lotus-1-2-3"

	// KMimeApplicationVndLotusApproach
	//
	// English:
	//
	//  Application type 'vnd.lotus-approach'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.lotus-approach'
	KMimeApplicationVndLotusApproach Mime = "application/vnd.lotus-approach"

	// KMimeApplicationVndLotusFreelance
	//
	// English:
	//
	//  Application type 'vnd.lotus-freelance'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.lotus-freelance'
	KMimeApplicationVndLotusFreelance Mime = "application/vnd.lotus-freelance"

	// KMimeApplicationVndLotusNotes
	//
	// English:
	//
	//  Application type 'vnd.lotus-notes'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.lotus-notes'
	KMimeApplicationVndLotusNotes Mime = "application/vnd.lotus-notes"

	// KMimeApplicationVndLotusOrganizer
	//
	// English:
	//
	//  Application type 'vnd.lotus-organizer'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.lotus-organizer'
	KMimeApplicationVndLotusOrganizer Mime = "application/vnd.lotus-organizer"

	// KMimeApplicationVndLotusScreencam
	//
	// English:
	//
	//  Application type 'vnd.lotus-screencam'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.lotus-screencam'
	KMimeApplicationVndLotusScreencam Mime = "application/vnd.lotus-screencam"

	// KMimeApplicationVndLotusWordpro
	//
	// English:
	//
	//  Application type 'vnd.lotus-wordpro'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.lotus-wordpro'
	KMimeApplicationVndLotusWordpro Mime = "application/vnd.lotus-wordpro"

	// KMimeApplicationVndMacportsPortpkg
	//
	// English:
	//
	//  Application type 'vnd.macports.portpkg'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.macports.portpkg'
	KMimeApplicationVndMacportsPortpkg Mime = "application/vnd.macports.portpkg"

	// KMimeApplicationVndMapboxVectorTile
	//
	// English:
	//
	//  Application type 'vnd.mapbox-vector-tile'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.mapbox-vector-tile'
	KMimeApplicationVndMapboxVectorTile Mime = "application/vnd.mapbox-vector-tile"

	// KMimeApplicationVndMarlinDrmActiontokenXml
	//
	// English:
	//
	//  Application type 'vnd.marlin.drm.actiontoken+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.marlin.drm.actiontoken+xml'
	KMimeApplicationVndMarlinDrmActiontokenXml Mime = "application/vnd.marlin.drm.actiontoken+xml"

	// KMimeApplicationVndMarlinDrmConftokenXml
	//
	// English:
	//
	//  Application type 'vnd.marlin.drm.conftoken+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.marlin.drm.conftoken+xml'
	KMimeApplicationVndMarlinDrmConftokenXml Mime = "application/vnd.marlin.drm.conftoken+xml"

	// KMimeApplicationVndMarlinDrmLicenseXml
	//
	// English:
	//
	//  Application type 'vnd.marlin.drm.license+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.marlin.drm.license+xml'
	KMimeApplicationVndMarlinDrmLicenseXml Mime = "application/vnd.marlin.drm.license+xml"

	// KMimeApplicationVndMarlinDrmMdcf
	//
	// English:
	//
	//  Application type 'vnd.marlin.drm.mdcf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.marlin.drm.mdcf'
	KMimeApplicationVndMarlinDrmMdcf Mime = "application/vnd.marlin.drm.mdcf"

	// KMimeApplicationVndMasonJson
	//
	// English:
	//
	//  Application type 'vnd.mason+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.mason+json'
	KMimeApplicationVndMasonJson Mime = "application/vnd.mason+json"

	// KMimeApplicationVndMaxarArchive3tzZip
	//
	// English:
	//
	//  Application type 'vnd.maxar.archive.3tz+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.maxar.archive.3tz+zip'
	KMimeApplicationVndMaxarArchive3tzZip Mime = "application/vnd.maxar.archive.3tz+zip"

	// KMimeApplicationVndMaxmindMaxmindDb
	//
	// English:
	//
	//  Application type 'vnd.maxmind.maxmind-db'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.maxmind.maxmind-db'
	KMimeApplicationVndMaxmindMaxmindDb Mime = "application/vnd.maxmind.maxmind-db"

	// KMimeApplicationVndMcd
	//
	// English:
	//
	//  Application type 'vnd.mcd'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.mcd'
	KMimeApplicationVndMcd Mime = "application/vnd.mcd"

	// KMimeApplicationVndMedcalcdata
	//
	// English:
	//
	//  Application type 'vnd.medcalcdata'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.medcalcdata'
	KMimeApplicationVndMedcalcdata Mime = "application/vnd.medcalcdata"

	// KMimeApplicationVndMediastationCdkey
	//
	// English:
	//
	//  Application type 'vnd.mediastation.cdkey'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.mediastation.cdkey'
	KMimeApplicationVndMediastationCdkey Mime = "application/vnd.mediastation.cdkey"

	// KMimeApplicationVndMeridianSlingshot
	//
	// English:
	//
	//  Application type 'vnd.meridian-slingshot'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.meridian-slingshot'
	KMimeApplicationVndMeridianSlingshot Mime = "application/vnd.meridian-slingshot"

	// KMimeApplicationVndMFER
	//
	// English:
	//
	//  Application type 'vnd.MFER'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.MFER'
	KMimeApplicationVndMFER Mime = "application/vnd.MFER"

	// KMimeApplicationVndMfmp
	//
	// English:
	//
	//  Application type 'vnd.mfmp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.mfmp'
	KMimeApplicationVndMfmp Mime = "application/vnd.mfmp"

	// KMimeApplicationVndMicroJson
	//
	// English:
	//
	//  Application type 'vnd.micro+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.micro+json'
	KMimeApplicationVndMicroJson Mime = "application/vnd.micro+json"

	// KMimeApplicationVndMicrografxFlo
	//
	// English:
	//
	//  Application type 'vnd.micrografx.flo'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.micrografx.flo'
	KMimeApplicationVndMicrografxFlo Mime = "application/vnd.micrografx.flo"

	// KMimeApplicationVndMicrografxIgx
	//
	// English:
	//
	//  Application type 'vnd.micrografx.igx'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.micrografx.igx'
	KMimeApplicationVndMicrografxIgx Mime = "application/vnd.micrografx.igx"

	// KMimeApplicationVndMicrosoftPortableExecutable
	//
	// English:
	//
	//  Application type 'vnd.microsoft.portable-executable'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.microsoft.portable-executable'
	KMimeApplicationVndMicrosoftPortableExecutable Mime = "application/vnd.microsoft.portable-executable"

	// KMimeApplicationVndMicrosoftWindowsThumbnailCache
	//
	// English:
	//
	//  Application type 'vnd.microsoft.windows.thumbnail-cache'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.microsoft.windows.thumbnail-cache'
	KMimeApplicationVndMicrosoftWindowsThumbnailCache Mime = "application/vnd.microsoft.windows.thumbnail-cache"

	// KMimeApplicationVndMieleJson
	//
	// English:
	//
	//  Application type 'vnd.miele+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.miele+json'
	KMimeApplicationVndMieleJson Mime = "application/vnd.miele+json"

	// KMimeApplicationVndMif
	//
	// English:
	//
	//  Application type 'vnd.mif'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.mif'
	KMimeApplicationVndMif Mime = "application/vnd.mif"

	// KMimeApplicationVndMinisoftHp3000Save
	//
	// English:
	//
	//  Application type 'vnd.minisoft-hp3000-save'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.minisoft-hp3000-save'
	KMimeApplicationVndMinisoftHp3000Save Mime = "application/vnd.minisoft-hp3000-save"

	// KMimeApplicationVndMitsubishiMistyGuardTrustweb
	//
	// English:
	//
	//  Application type 'vnd.mitsubishi.misty-guard.trustweb'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.mitsubishi.misty-guard.trustweb'
	KMimeApplicationVndMitsubishiMistyGuardTrustweb Mime = "application/vnd.mitsubishi.misty-guard.trustweb"

	// KMimeApplicationVndMobiusDAF
	//
	// English:
	//
	//  Application type 'vnd.Mobius.DAF'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.Mobius.DAF'
	KMimeApplicationVndMobiusDAF Mime = "application/vnd.Mobius.DAF"

	// KMimeApplicationVndMobiusDIS
	//
	// English:
	//
	//  Application type 'vnd.Mobius.DIS'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.Mobius.DIS'
	KMimeApplicationVndMobiusDIS Mime = "application/vnd.Mobius.DIS"

	// KMimeApplicationVndMobiusMBK
	//
	// English:
	//
	//  Application type 'vnd.Mobius.MBK'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.Mobius.MBK'
	KMimeApplicationVndMobiusMBK Mime = "application/vnd.Mobius.MBK"

	// KMimeApplicationVndMobiusMQY
	//
	// English:
	//
	//  Application type 'vnd.Mobius.MQY'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.Mobius.MQY'
	KMimeApplicationVndMobiusMQY Mime = "application/vnd.Mobius.MQY"

	// KMimeApplicationVndMobiusMSL
	//
	// English:
	//
	//  Application type 'vnd.Mobius.MSL'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.Mobius.MSL'
	KMimeApplicationVndMobiusMSL Mime = "application/vnd.Mobius.MSL"

	// KMimeApplicationVndMobiusPLC
	//
	// English:
	//
	//  Application type 'vnd.Mobius.PLC'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.Mobius.PLC'
	KMimeApplicationVndMobiusPLC Mime = "application/vnd.Mobius.PLC"

	// KMimeApplicationVndMobiusTXF
	//
	// English:
	//
	//  Application type 'vnd.Mobius.TXF'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.Mobius.TXF'
	KMimeApplicationVndMobiusTXF Mime = "application/vnd.Mobius.TXF"

	// KMimeApplicationVndMophunApplication
	//
	// English:
	//
	//  Application type 'vnd.mophun.application'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.mophun.application'
	KMimeApplicationVndMophunApplication Mime = "application/vnd.mophun.application"

	// KMimeApplicationVndMophunCertificate
	//
	// English:
	//
	//  Application type 'vnd.mophun.certificate'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.mophun.certificate'
	KMimeApplicationVndMophunCertificate Mime = "application/vnd.mophun.certificate"

	// KMimeApplicationVndMotorolaFlexsuite
	//
	// English:
	//
	//  Application type 'vnd.motorola.flexsuite'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.motorola.flexsuite'
	KMimeApplicationVndMotorolaFlexsuite Mime = "application/vnd.motorola.flexsuite"

	// KMimeApplicationVndMotorolaFlexsuiteAdsi
	//
	// English:
	//
	//  Application type 'vnd.motorola.flexsuite.adsi'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.motorola.flexsuite.adsi'
	KMimeApplicationVndMotorolaFlexsuiteAdsi Mime = "application/vnd.motorola.flexsuite.adsi"

	// KMimeApplicationVndMotorolaFlexsuiteFis
	//
	// English:
	//
	//  Application type 'vnd.motorola.flexsuite.fis'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.motorola.flexsuite.fis'
	KMimeApplicationVndMotorolaFlexsuiteFis Mime = "application/vnd.motorola.flexsuite.fis"

	// KMimeApplicationVndMotorolaFlexsuiteGotap
	//
	// English:
	//
	//  Application type 'vnd.motorola.flexsuite.gotap'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.motorola.flexsuite.gotap'
	KMimeApplicationVndMotorolaFlexsuiteGotap Mime = "application/vnd.motorola.flexsuite.gotap"

	// KMimeApplicationVndMotorolaFlexsuiteKmr
	//
	// English:
	//
	//  Application type 'vnd.motorola.flexsuite.kmr'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.motorola.flexsuite.kmr'
	KMimeApplicationVndMotorolaFlexsuiteKmr Mime = "application/vnd.motorola.flexsuite.kmr"

	// KMimeApplicationVndMotorolaFlexsuiteTtc
	//
	// English:
	//
	//  Application type 'vnd.motorola.flexsuite.ttc'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.motorola.flexsuite.ttc'
	KMimeApplicationVndMotorolaFlexsuiteTtc Mime = "application/vnd.motorola.flexsuite.ttc"

	// KMimeApplicationVndMotorolaFlexsuiteWem
	//
	// English:
	//
	//  Application type 'vnd.motorola.flexsuite.wem'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.motorola.flexsuite.wem'
	KMimeApplicationVndMotorolaFlexsuiteWem Mime = "application/vnd.motorola.flexsuite.wem"

	// KMimeApplicationVndMotorolaIprm
	//
	// English:
	//
	//  Application type 'vnd.motorola.iprm'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.motorola.iprm'
	KMimeApplicationVndMotorolaIprm Mime = "application/vnd.motorola.iprm"

	// KMimeApplicationVndMozillaXulXml
	//
	// English:
	//
	//  Application type 'vnd.mozilla.xul+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.mozilla.xul+xml'
	KMimeApplicationVndMozillaXulXml Mime = "application/vnd.mozilla.xul+xml"

	// KMimeApplicationVndMsArtgalry
	//
	// English:
	//
	//  Application type 'vnd.ms-artgalry'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-artgalry'
	KMimeApplicationVndMsArtgalry Mime = "application/vnd.ms-artgalry"

	// KMimeApplicationVndMsAsf
	//
	// English:
	//
	//  Application type 'vnd.ms-asf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-asf'
	KMimeApplicationVndMsAsf Mime = "application/vnd.ms-asf"

	// KMimeApplicationVndMsCabCompressed
	//
	// English:
	//
	//  Application type 'vnd.ms-cab-compressed'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-cab-compressed'
	KMimeApplicationVndMsCabCompressed Mime = "application/vnd.ms-cab-compressed"

	// KMimeApplicationVndMs3mfdocument
	//
	// English:
	//
	//  Application type 'vnd.ms-3mfdocument'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-3mfdocument'
	KMimeApplicationVndMs3mfdocument Mime = "application/vnd.ms-3mfdocument"

	// KMimeApplicationVndMsExcel
	//
	// English:
	//
	//  Application type 'vnd.ms-excel'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-excel'
	KMimeApplicationVndMsExcel Mime = "application/vnd.ms-excel"

	// KMimeApplicationVndMsExcelAddinMacroEnabled12
	//
	// English:
	//
	//  Application type 'vnd.ms-excel.addin.macroEnabled.12'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-excel.addin.macroEnabled.12'
	KMimeApplicationVndMsExcelAddinMacroEnabled12 Mime = "application/vnd.ms-excel.addin.macroEnabled.12"

	// KMimeApplicationVndMsExcelSheetBinaryMacroEnabled12
	//
	// English:
	//
	//  Application type 'vnd.ms-excel.sheet.binary.macroEnabled.12'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-excel.sheet.binary.macroEnabled.12'
	KMimeApplicationVndMsExcelSheetBinaryMacroEnabled12 Mime = "application/vnd.ms-excel.sheet.binary.macroEnabled.12"

	// KMimeApplicationVndMsExcelSheetMacroEnabled12
	//
	// English:
	//
	//  Application type 'vnd.ms-excel.sheet.macroEnabled.12'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-excel.sheet.macroEnabled.12'
	KMimeApplicationVndMsExcelSheetMacroEnabled12 Mime = "application/vnd.ms-excel.sheet.macroEnabled.12"

	// KMimeApplicationVndMsExcelTemplateMacroEnabled12
	//
	// English:
	//
	//  Application type 'vnd.ms-excel.template.macroEnabled.12'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-excel.template.macroEnabled.12'
	KMimeApplicationVndMsExcelTemplateMacroEnabled12 Mime = "application/vnd.ms-excel.template.macroEnabled.12"

	// KMimeApplicationVndMsFontobject
	//
	// English:
	//
	//  Application type 'vnd.ms-fontobject'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-fontobject'
	KMimeApplicationVndMsFontobject Mime = "application/vnd.ms-fontobject"

	// KMimeApplicationVndMsHtmlhelp
	//
	// English:
	//
	//  Application type 'vnd.ms-htmlhelp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-htmlhelp'
	KMimeApplicationVndMsHtmlhelp Mime = "application/vnd.ms-htmlhelp"

	// KMimeApplicationVndMsIms
	//
	// English:
	//
	//  Application type 'vnd.ms-ims'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-ims'
	KMimeApplicationVndMsIms Mime = "application/vnd.ms-ims"

	// KMimeApplicationVndMsLrm
	//
	// English:
	//
	//  Application type 'vnd.ms-lrm'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-lrm'
	KMimeApplicationVndMsLrm Mime = "application/vnd.ms-lrm"

	// KMimeApplicationVndMsOfficeActiveXXml
	//
	// English:
	//
	//  Application type 'vnd.ms-office.activeX+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-office.activeX+xml'
	KMimeApplicationVndMsOfficeActiveXXml Mime = "application/vnd.ms-office.activeX+xml"

	// KMimeApplicationVndMsOfficetheme
	//
	// English:
	//
	//  Application type 'vnd.ms-officetheme'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-officetheme'
	KMimeApplicationVndMsOfficetheme Mime = "application/vnd.ms-officetheme"

	// KMimeApplicationVndMsPlayreadyInitiatorXml
	//
	// English:
	//
	//  Application type 'vnd.ms-playready.initiator+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-playready.initiator+xml'
	KMimeApplicationVndMsPlayreadyInitiatorXml Mime = "application/vnd.ms-playready.initiator+xml"

	// KMimeApplicationVndMsPowerpoint
	//
	// English:
	//
	//  Application type 'vnd.ms-powerpoint'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-powerpoint'
	KMimeApplicationVndMsPowerpoint Mime = "application/vnd.ms-powerpoint"

	// KMimeApplicationVndMsPowerpointAddinMacroEnabled12
	//
	// English:
	//
	//  Application type 'vnd.ms-powerpoint.addin.macroEnabled.12'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-powerpoint.addin.macroEnabled.12'
	KMimeApplicationVndMsPowerpointAddinMacroEnabled12 Mime = "application/vnd.ms-powerpoint.addin.macroEnabled.12"

	// KMimeApplicationVndMsPowerpointPresentationMacroEnabled12
	//
	// English:
	//
	//  Application type 'vnd.ms-powerpoint.presentation.macroEnabled.12'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-powerpoint.presentation.macroEnabled.12'
	KMimeApplicationVndMsPowerpointPresentationMacroEnabled12 Mime = "application/vnd.ms-powerpoint.presentation.macroEnabled.12"

	// KMimeApplicationVndMsPowerpointSlideMacroEnabled12
	//
	// English:
	//
	//  Application type 'vnd.ms-powerpoint.slide.macroEnabled.12'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-powerpoint.slide.macroEnabled.12'
	KMimeApplicationVndMsPowerpointSlideMacroEnabled12 Mime = "application/vnd.ms-powerpoint.slide.macroEnabled.12"

	// KMimeApplicationVndMsPowerpointSlideshowMacroEnabled12
	//
	// English:
	//
	//  Application type 'vnd.ms-powerpoint.slideshow.macroEnabled.12'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-powerpoint.slideshow.macroEnabled.12'
	KMimeApplicationVndMsPowerpointSlideshowMacroEnabled12 Mime = "application/vnd.ms-powerpoint.slideshow.macroEnabled.12"

	// KMimeApplicationVndMsPowerpointTemplateMacroEnabled12
	//
	// English:
	//
	//  Application type 'vnd.ms-powerpoint.template.macroEnabled.12'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-powerpoint.template.macroEnabled.12'
	KMimeApplicationVndMsPowerpointTemplateMacroEnabled12 Mime = "application/vnd.ms-powerpoint.template.macroEnabled.12"

	// KMimeApplicationVndMsPrintDeviceCapabilitiesXml
	//
	// English:
	//
	//  Application type 'vnd.ms-PrintDeviceCapabilities+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-PrintDeviceCapabilities+xml'
	KMimeApplicationVndMsPrintDeviceCapabilitiesXml Mime = "application/vnd.ms-PrintDeviceCapabilities+xml"

	// KMimeApplicationVndMsPrintSchemaTicketXml
	//
	// English:
	//
	//  Application type 'vnd.ms-PrintSchemaTicket+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-PrintSchemaTicket+xml'
	KMimeApplicationVndMsPrintSchemaTicketXml Mime = "application/vnd.ms-PrintSchemaTicket+xml"

	// KMimeApplicationVndMsProject
	//
	// English:
	//
	//  Application type 'vnd.ms-project'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-project'
	KMimeApplicationVndMsProject Mime = "application/vnd.ms-project"

	// KMimeApplicationVndMsTnef
	//
	// English:
	//
	//  Application type 'vnd.ms-tnef'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-tnef'
	KMimeApplicationVndMsTnef Mime = "application/vnd.ms-tnef"

	// KMimeApplicationVndMsWindowsDevicepairing
	//
	// English:
	//
	//  Application type 'vnd.ms-windows.devicepairing'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-windows.devicepairing'
	KMimeApplicationVndMsWindowsDevicepairing Mime = "application/vnd.ms-windows.devicepairing"

	// KMimeApplicationVndMsWindowsNwprintingOob
	//
	// English:
	//
	//  Application type 'vnd.ms-windows.nwprinting.oob'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-windows.nwprinting.oob'
	KMimeApplicationVndMsWindowsNwprintingOob Mime = "application/vnd.ms-windows.nwprinting.oob"

	// KMimeApplicationVndMsWindowsPrinterpairing
	//
	// English:
	//
	//  Application type 'vnd.ms-windows.printerpairing'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-windows.printerpairing'
	KMimeApplicationVndMsWindowsPrinterpairing Mime = "application/vnd.ms-windows.printerpairing"

	// KMimeApplicationVndMsWindowsWsdOob
	//
	// English:
	//
	//  Application type 'vnd.ms-windows.wsd.oob'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-windows.wsd.oob'
	KMimeApplicationVndMsWindowsWsdOob Mime = "application/vnd.ms-windows.wsd.oob"

	// KMimeApplicationVndMsWmdrmLicChlgReq
	//
	// English:
	//
	//  Application type 'vnd.ms-wmdrm.lic-chlg-req'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-wmdrm.lic-chlg-req'
	KMimeApplicationVndMsWmdrmLicChlgReq Mime = "application/vnd.ms-wmdrm.lic-chlg-req"

	// KMimeApplicationVndMsWmdrmLicResp
	//
	// English:
	//
	//  Application type 'vnd.ms-wmdrm.lic-resp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-wmdrm.lic-resp'
	KMimeApplicationVndMsWmdrmLicResp Mime = "application/vnd.ms-wmdrm.lic-resp"

	// KMimeApplicationVndMsWmdrmMeterChlgReq
	//
	// English:
	//
	//  Application type 'vnd.ms-wmdrm.meter-chlg-req'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-wmdrm.meter-chlg-req'
	KMimeApplicationVndMsWmdrmMeterChlgReq Mime = "application/vnd.ms-wmdrm.meter-chlg-req"

	// KMimeApplicationVndMsWmdrmMeterResp
	//
	// English:
	//
	//  Application type 'vnd.ms-wmdrm.meter-resp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-wmdrm.meter-resp'
	KMimeApplicationVndMsWmdrmMeterResp Mime = "application/vnd.ms-wmdrm.meter-resp"

	// KMimeApplicationVndMsWordDocumentMacroEnabled12
	//
	// English:
	//
	//  Application type 'vnd.ms-word.document.macroEnabled.12'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-word.document.macroEnabled.12'
	KMimeApplicationVndMsWordDocumentMacroEnabled12 Mime = "application/vnd.ms-word.document.macroEnabled.12"

	// KMimeApplicationVndMsWordTemplateMacroEnabled12
	//
	// English:
	//
	//  Application type 'vnd.ms-word.template.macroEnabled.12'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-word.template.macroEnabled.12'
	KMimeApplicationVndMsWordTemplateMacroEnabled12 Mime = "application/vnd.ms-word.template.macroEnabled.12"

	// KMimeApplicationVndMsWorks
	//
	// English:
	//
	//  Application type 'vnd.ms-works'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-works'
	KMimeApplicationVndMsWorks Mime = "application/vnd.ms-works"

	// KMimeApplicationVndMsWpl
	//
	// English:
	//
	//  Application type 'vnd.ms-wpl'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-wpl'
	KMimeApplicationVndMsWpl Mime = "application/vnd.ms-wpl"

	// KMimeApplicationVndMsXpsdocument
	//
	// English:
	//
	//  Application type 'vnd.ms-xpsdocument'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-xpsdocument'
	KMimeApplicationVndMsXpsdocument Mime = "application/vnd.ms-xpsdocument"

	// KMimeApplicationVndMsaDiskImage
	//
	// English:
	//
	//  Application type 'vnd.msa-disk-image'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.msa-disk-image'
	KMimeApplicationVndMsaDiskImage Mime = "application/vnd.msa-disk-image"

	// KMimeApplicationVndMseq
	//
	// English:
	//
	//  Application type 'vnd.mseq'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.mseq'
	KMimeApplicationVndMseq Mime = "application/vnd.mseq"

	// KMimeApplicationVndMsign
	//
	// English:
	//
	//  Application type 'vnd.msign'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.msign'
	KMimeApplicationVndMsign Mime = "application/vnd.msign"

	// KMimeApplicationVndMultiadCreator
	//
	// English:
	//
	//  Application type 'vnd.multiad.creator'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.multiad.creator'
	KMimeApplicationVndMultiadCreator Mime = "application/vnd.multiad.creator"

	// KMimeApplicationVndMultiadCreatorCif
	//
	// English:
	//
	//  Application type 'vnd.multiad.creator.cif'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.multiad.creator.cif'
	KMimeApplicationVndMultiadCreatorCif Mime = "application/vnd.multiad.creator.cif"

	// KMimeApplicationVndMusician
	//
	// English:
	//
	//  Application type 'vnd.musician'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.musician'
	KMimeApplicationVndMusician Mime = "application/vnd.musician"

	// KMimeApplicationVndMusicNiff
	//
	// English:
	//
	//  Application type 'vnd.music-niff'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.music-niff'
	KMimeApplicationVndMusicNiff Mime = "application/vnd.music-niff"

	// KMimeApplicationVndMuveeStyle
	//
	// English:
	//
	//  Application type 'vnd.muvee.style'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.muvee.style'
	KMimeApplicationVndMuveeStyle Mime = "application/vnd.muvee.style"

	// KMimeApplicationVndMynfc
	//
	// English:
	//
	//  Application type 'vnd.mynfc'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.mynfc'
	KMimeApplicationVndMynfc Mime = "application/vnd.mynfc"

	// KMimeApplicationVndNacamarYbridJson
	//
	// English:
	//
	//  Application type 'vnd.nacamar.ybrid+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nacamar.ybrid+json'
	KMimeApplicationVndNacamarYbridJson Mime = "application/vnd.nacamar.ybrid+json"

	// KMimeApplicationVndNcdControl
	//
	// English:
	//
	//  Application type 'vnd.ncd.control'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ncd.control'
	KMimeApplicationVndNcdControl Mime = "application/vnd.ncd.control"

	// KMimeApplicationVndNcdReference
	//
	// English:
	//
	//  Application type 'vnd.ncd.reference'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ncd.reference'
	KMimeApplicationVndNcdReference Mime = "application/vnd.ncd.reference"

	// KMimeApplicationVndNearstInvJson
	//
	// English:
	//
	//  Application type 'vnd.nearst.inv+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nearst.inv+json'
	KMimeApplicationVndNearstInvJson Mime = "application/vnd.nearst.inv+json"

	// KMimeApplicationVndNebumindLine
	//
	// English:
	//
	//  Application type 'vnd.nebumind.line'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nebumind.line'
	KMimeApplicationVndNebumindLine Mime = "application/vnd.nebumind.line"

	// KMimeApplicationVndNervana
	//
	// English:
	//
	//  Application type 'vnd.nervana'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nervana'
	KMimeApplicationVndNervana Mime = "application/vnd.nervana"

	// KMimeApplicationVndNetfpx
	//
	// English:
	//
	//  Application type 'vnd.netfpx'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.netfpx'
	KMimeApplicationVndNetfpx Mime = "application/vnd.netfpx"

	// KMimeApplicationVndNeurolanguageNlu
	//
	// English:
	//
	//  Application type 'vnd.neurolanguage.nlu'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.neurolanguage.nlu'
	KMimeApplicationVndNeurolanguageNlu Mime = "application/vnd.neurolanguage.nlu"

	// KMimeApplicationVndNimn
	//
	// English:
	//
	//  Application type 'vnd.nimn'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nimn'
	KMimeApplicationVndNimn Mime = "application/vnd.nimn"

	// KMimeApplicationVndNintendoSnesRom
	//
	// English:
	//
	//  Application type 'vnd.nintendo.snes.rom'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nintendo.snes.rom'
	KMimeApplicationVndNintendoSnesRom Mime = "application/vnd.nintendo.snes.rom"

	// KMimeApplicationVndNintendoNitroRom
	//
	// English:
	//
	//  Application type 'vnd.nintendo.nitro.rom'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nintendo.nitro.rom'
	KMimeApplicationVndNintendoNitroRom Mime = "application/vnd.nintendo.nitro.rom"

	// KMimeApplicationVndNitf
	//
	// English:
	//
	//  Application type 'vnd.nitf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nitf'
	KMimeApplicationVndNitf Mime = "application/vnd.nitf"

	// KMimeApplicationVndNoblenetDirectory
	//
	// English:
	//
	//  Application type 'vnd.noblenet-directory'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.noblenet-directory'
	KMimeApplicationVndNoblenetDirectory Mime = "application/vnd.noblenet-directory"

	// KMimeApplicationVndNoblenetSealer
	//
	// English:
	//
	//  Application type 'vnd.noblenet-sealer'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.noblenet-sealer'
	KMimeApplicationVndNoblenetSealer Mime = "application/vnd.noblenet-sealer"

	// KMimeApplicationVndNoblenetWeb
	//
	// English:
	//
	//  Application type 'vnd.noblenet-web'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.noblenet-web'
	KMimeApplicationVndNoblenetWeb Mime = "application/vnd.noblenet-web"

	// KMimeApplicationVndNokiaCatalogs
	//
	// English:
	//
	//  Application type 'vnd.nokia.catalogs'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nokia.catalogs'
	KMimeApplicationVndNokiaCatalogs Mime = "application/vnd.nokia.catalogs"

	// KMimeApplicationVndNokiaConmlWbxml
	//
	// English:
	//
	//  Application type 'vnd.nokia.conml+wbxml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nokia.conml+wbxml'
	KMimeApplicationVndNokiaConmlWbxml Mime = "application/vnd.nokia.conml+wbxml"

	// KMimeApplicationVndNokiaConmlXml
	//
	// English:
	//
	//  Application type 'vnd.nokia.conml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nokia.conml+xml'
	KMimeApplicationVndNokiaConmlXml Mime = "application/vnd.nokia.conml+xml"

	// KMimeApplicationVndNokiaIptvConfigXml
	//
	// English:
	//
	//  Application type 'vnd.nokia.iptv.config+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nokia.iptv.config+xml'
	KMimeApplicationVndNokiaIptvConfigXml Mime = "application/vnd.nokia.iptv.config+xml"

	// KMimeApplicationVndNokiaISDSRadioPresets
	//
	// English:
	//
	//  Application type 'vnd.nokia.iSDS-radio-presets'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nokia.iSDS-radio-presets'
	KMimeApplicationVndNokiaISDSRadioPresets Mime = "application/vnd.nokia.iSDS-radio-presets"

	// KMimeApplicationVndNokiaLandmarkWbxml
	//
	// English:
	//
	//  Application type 'vnd.nokia.landmark+wbxml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nokia.landmark+wbxml'
	KMimeApplicationVndNokiaLandmarkWbxml Mime = "application/vnd.nokia.landmark+wbxml"

	// KMimeApplicationVndNokiaLandmarkXml
	//
	// English:
	//
	//  Application type 'vnd.nokia.landmark+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nokia.landmark+xml'
	KMimeApplicationVndNokiaLandmarkXml Mime = "application/vnd.nokia.landmark+xml"

	// KMimeApplicationVndNokiaLandmarkcollectionXml
	//
	// English:
	//
	//  Application type 'vnd.nokia.landmarkcollection+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nokia.landmarkcollection+xml'
	KMimeApplicationVndNokiaLandmarkcollectionXml Mime = "application/vnd.nokia.landmarkcollection+xml"

	// KMimeApplicationVndNokiaNcd
	//
	// English:
	//
	//  Application type 'vnd.nokia.ncd'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nokia.ncd'
	KMimeApplicationVndNokiaNcd Mime = "application/vnd.nokia.ncd"

	// KMimeApplicationVndNokiaNGageAcXml
	//
	// English:
	//
	//  Application type 'vnd.nokia.n-gage.ac+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nokia.n-gage.ac+xml'
	KMimeApplicationVndNokiaNGageAcXml Mime = "application/vnd.nokia.n-gage.ac+xml"

	// KMimeApplicationVndNokiaNGageData
	//
	// English:
	//
	//  Application type 'vnd.nokia.n-gage.data'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nokia.n-gage.data'
	KMimeApplicationVndNokiaNGageData Mime = "application/vnd.nokia.n-gage.data"

	// KMimeApplicationVndNokiaNGageSymbianInstall
	//
	// English:
	//
	//  Application type 'vnd.nokia.n-gage.symbian.install'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nokia.n-gage.symbian.install'
	KMimeApplicationVndNokiaNGageSymbianInstall Mime = "(OBSOLETE;"

	// KMimeApplicationVndNokiaPcdWbxml
	//
	// English:
	//
	//  Application type 'vnd.nokia.pcd+wbxml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nokia.pcd+wbxml'
	KMimeApplicationVndNokiaPcdWbxml Mime = "application/vnd.nokia.pcd+wbxml"

	// KMimeApplicationVndNokiaPcdXml
	//
	// English:
	//
	//  Application type 'vnd.nokia.pcd+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nokia.pcd+xml'
	KMimeApplicationVndNokiaPcdXml Mime = "application/vnd.nokia.pcd+xml"

	// KMimeApplicationVndNokiaRadioPreset
	//
	// English:
	//
	//  Application type 'vnd.nokia.radio-preset'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nokia.radio-preset'
	KMimeApplicationVndNokiaRadioPreset Mime = "application/vnd.nokia.radio-preset"

	// KMimeApplicationVndNokiaRadioPresets
	//
	// English:
	//
	//  Application type 'vnd.nokia.radio-presets'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nokia.radio-presets'
	KMimeApplicationVndNokiaRadioPresets Mime = "application/vnd.nokia.radio-presets"

	// KMimeApplicationVndNovadigmEDM
	//
	// English:
	//
	//  Application type 'vnd.novadigm.EDM'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.novadigm.EDM'
	KMimeApplicationVndNovadigmEDM Mime = "application/vnd.novadigm.EDM"

	// KMimeApplicationVndNovadigmEDX
	//
	// English:
	//
	//  Application type 'vnd.novadigm.EDX'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.novadigm.EDX'
	KMimeApplicationVndNovadigmEDX Mime = "application/vnd.novadigm.EDX"

	// KMimeApplicationVndNovadigmEXT
	//
	// English:
	//
	//  Application type 'vnd.novadigm.EXT'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.novadigm.EXT'
	KMimeApplicationVndNovadigmEXT Mime = "application/vnd.novadigm.EXT"

	// KMimeApplicationVndNttLocalContentShare
	//
	// English:
	//
	//  Application type 'vnd.ntt-local.content-share'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ntt-local.content-share'
	KMimeApplicationVndNttLocalContentShare Mime = "application/vnd.ntt-local.content-share"

	// KMimeApplicationVndNttLocalFileTransfer
	//
	// English:
	//
	//  Application type 'vnd.ntt-local.file-transfer'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ntt-local.file-transfer'
	KMimeApplicationVndNttLocalFileTransfer Mime = "application/vnd.ntt-local.file-transfer"

	// KMimeApplicationVndNttLocalOgwRemoteAccess
	//
	// English:
	//
	//  Application type 'vnd.ntt-local.ogw_remote-access'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ntt-local.ogw_remote-access'
	KMimeApplicationVndNttLocalOgwRemoteAccess Mime = "application/vnd.ntt-local.ogw_remote-access"

	// KMimeApplicationVndNttLocalSipTaRemote
	//
	// English:
	//
	//  Application type 'vnd.ntt-local.sip-ta_remote'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ntt-local.sip-ta_remote'
	KMimeApplicationVndNttLocalSipTaRemote Mime = "application/vnd.ntt-local.sip-ta_remote"

	// KMimeApplicationVndNttLocalSipTaTcpStream
	//
	// English:
	//
	//  Application type 'vnd.ntt-local.sip-ta_tcp_stream'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ntt-local.sip-ta_tcp_stream'
	KMimeApplicationVndNttLocalSipTaTcpStream Mime = "application/vnd.ntt-local.sip-ta_tcp_stream"

	// KMimeApplicationVndOasisOpendocumentChart
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.chart'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.chart'
	KMimeApplicationVndOasisOpendocumentChart Mime = "application/vnd.oasis.opendocument.chart"

	// KMimeApplicationVndOasisOpendocumentChartTemplate
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.chart-template'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.chart-template'
	KMimeApplicationVndOasisOpendocumentChartTemplate Mime = "application/vnd.oasis.opendocument.chart-template"

	// KMimeApplicationVndOasisOpendocumentDatabase
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.database'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.database'
	KMimeApplicationVndOasisOpendocumentDatabase Mime = "application/vnd.oasis.opendocument.database"

	// KMimeApplicationVndOasisOpendocumentFormula
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.formula'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.formula'
	KMimeApplicationVndOasisOpendocumentFormula Mime = "application/vnd.oasis.opendocument.formula"

	// KMimeApplicationVndOasisOpendocumentFormulaTemplate
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.formula-template'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.formula-template'
	KMimeApplicationVndOasisOpendocumentFormulaTemplate Mime = "application/vnd.oasis.opendocument.formula-template"

	// KMimeApplicationVndOasisOpendocumentGraphics
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.graphics'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.graphics'
	KMimeApplicationVndOasisOpendocumentGraphics Mime = "application/vnd.oasis.opendocument.graphics"

	// KMimeApplicationVndOasisOpendocumentGraphicsTemplate
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.graphics-template'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.graphics-template'
	KMimeApplicationVndOasisOpendocumentGraphicsTemplate Mime = "application/vnd.oasis.opendocument.graphics-template"

	// KMimeApplicationVndOasisOpendocumentImage
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.image'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.image'
	KMimeApplicationVndOasisOpendocumentImage Mime = "application/vnd.oasis.opendocument.image"

	// KMimeApplicationVndOasisOpendocumentImageTemplate
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.image-template'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.image-template'
	KMimeApplicationVndOasisOpendocumentImageTemplate Mime = "application/vnd.oasis.opendocument.image-template"

	// KMimeApplicationVndOasisOpendocumentPresentation
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.presentation'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.presentation'
	KMimeApplicationVndOasisOpendocumentPresentation Mime = "application/vnd.oasis.opendocument.presentation"

	// KMimeApplicationVndOasisOpendocumentPresentationTemplate
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.presentation-template'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.presentation-template'
	KMimeApplicationVndOasisOpendocumentPresentationTemplate Mime = "application/vnd.oasis.opendocument.presentation-template"

	// KMimeApplicationVndOasisOpendocumentSpreadsheet
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.spreadsheet'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.spreadsheet'
	KMimeApplicationVndOasisOpendocumentSpreadsheet Mime = "application/vnd.oasis.opendocument.spreadsheet"

	// KMimeApplicationVndOasisOpendocumentSpreadsheetTemplate
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.spreadsheet-template'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.spreadsheet-template'
	KMimeApplicationVndOasisOpendocumentSpreadsheetTemplate Mime = "application/vnd.oasis.opendocument.spreadsheet-template"

	// KMimeApplicationVndOasisOpendocumentText
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.text'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.text'
	KMimeApplicationVndOasisOpendocumentText Mime = "application/vnd.oasis.opendocument.text"

	// KMimeApplicationVndOasisOpendocumentTextMaster
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.text-master'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.text-master'
	KMimeApplicationVndOasisOpendocumentTextMaster Mime = "application/vnd.oasis.opendocument.text-master"

	// KMimeApplicationVndOasisOpendocumentTextTemplate
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.text-template'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.text-template'
	KMimeApplicationVndOasisOpendocumentTextTemplate Mime = "application/vnd.oasis.opendocument.text-template"

	// KMimeApplicationVndOasisOpendocumentTextWeb
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.text-web'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.text-web'
	KMimeApplicationVndOasisOpendocumentTextWeb Mime = "application/vnd.oasis.opendocument.text-web"

	// KMimeApplicationVndObn
	//
	// English:
	//
	//  Application type 'vnd.obn'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.obn'
	KMimeApplicationVndObn Mime = "application/vnd.obn"

	// KMimeApplicationVndOcfCbor
	//
	// English:
	//
	//  Application type 'vnd.ocf+cbor'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ocf+cbor'
	KMimeApplicationVndOcfCbor Mime = "application/vnd.ocf+cbor"

	// KMimeApplicationVndOciImageManifestV1Json
	//
	// English:
	//
	//  Application type 'vnd.oci.image.manifest.v1+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oci.image.manifest.v1+json'
	KMimeApplicationVndOciImageManifestV1Json Mime = "application/vnd.oci.image.manifest.v1+json"

	// KMimeApplicationVndOftnL10nJson
	//
	// English:
	//
	//  Application type 'vnd.oftn.l10n+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oftn.l10n+json'
	KMimeApplicationVndOftnL10nJson Mime = "application/vnd.oftn.l10n+json"

	// KMimeApplicationVndOipfContentaccessdownloadXml
	//
	// English:
	//
	//  Application type 'vnd.oipf.contentaccessdownload+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oipf.contentaccessdownload+xml'
	KMimeApplicationVndOipfContentaccessdownloadXml Mime = "application/vnd.oipf.contentaccessdownload+xml"

	// KMimeApplicationVndOipfContentaccessstreamingXml
	//
	// English:
	//
	//  Application type 'vnd.oipf.contentaccessstreaming+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oipf.contentaccessstreaming+xml'
	KMimeApplicationVndOipfContentaccessstreamingXml Mime = "application/vnd.oipf.contentaccessstreaming+xml"

	// KMimeApplicationVndOipfCspgHexbinary
	//
	// English:
	//
	//  Application type 'vnd.oipf.cspg-hexbinary'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oipf.cspg-hexbinary'
	KMimeApplicationVndOipfCspgHexbinary Mime = "application/vnd.oipf.cspg-hexbinary"

	// KMimeApplicationVndOipfDaeSvgXml
	//
	// English:
	//
	//  Application type 'vnd.oipf.dae.svg+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oipf.dae.svg+xml'
	KMimeApplicationVndOipfDaeSvgXml Mime = "application/vnd.oipf.dae.svg+xml"

	// KMimeApplicationVndOipfDaeXhtmlXml
	//
	// English:
	//
	//  Application type 'vnd.oipf.dae.xhtml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oipf.dae.xhtml+xml'
	KMimeApplicationVndOipfDaeXhtmlXml Mime = "application/vnd.oipf.dae.xhtml+xml"

	// KMimeApplicationVndOipfMippvcontrolmessageXml
	//
	// English:
	//
	//  Application type 'vnd.oipf.mippvcontrolmessage+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oipf.mippvcontrolmessage+xml'
	KMimeApplicationVndOipfMippvcontrolmessageXml Mime = "application/vnd.oipf.mippvcontrolmessage+xml"

	// KMimeApplicationVndOipfPaeGem
	//
	// English:
	//
	//  Application type 'vnd.oipf.pae.gem'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oipf.pae.gem'
	KMimeApplicationVndOipfPaeGem Mime = "application/vnd.oipf.pae.gem"

	// KMimeApplicationVndOipfSpdiscoveryXml
	//
	// English:
	//
	//  Application type 'vnd.oipf.spdiscovery+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oipf.spdiscovery+xml'
	KMimeApplicationVndOipfSpdiscoveryXml Mime = "application/vnd.oipf.spdiscovery+xml"

	// KMimeApplicationVndOipfSpdlistXml
	//
	// English:
	//
	//  Application type 'vnd.oipf.spdlist+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oipf.spdlist+xml'
	KMimeApplicationVndOipfSpdlistXml Mime = "application/vnd.oipf.spdlist+xml"

	// KMimeApplicationVndOipfUeprofileXml
	//
	// English:
	//
	//  Application type 'vnd.oipf.ueprofile+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oipf.ueprofile+xml'
	KMimeApplicationVndOipfUeprofileXml Mime = "application/vnd.oipf.ueprofile+xml"

	// KMimeApplicationVndOipfUserprofileXml
	//
	// English:
	//
	//  Application type 'vnd.oipf.userprofile+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oipf.userprofile+xml'
	KMimeApplicationVndOipfUserprofileXml Mime = "application/vnd.oipf.userprofile+xml"

	// KMimeApplicationVndOlpcSugar
	//
	// English:
	//
	//  Application type 'vnd.olpc-sugar'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.olpc-sugar'
	KMimeApplicationVndOlpcSugar Mime = "application/vnd.olpc-sugar"

	// KMimeApplicationVndOmaBcastAssociatedProcedureParameterXml
	//
	// English:
	//
	//  Application type 'vnd.oma.bcast.associated-procedure-parameter+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.bcast.associated-procedure-parameter+xml'
	KMimeApplicationVndOmaBcastAssociatedProcedureParameterXml Mime = "application/vnd.oma.bcast.associated-procedure-parameter+xml"

	// KMimeApplicationVndOmaBcastDrmTriggerXml
	//
	// English:
	//
	//  Application type 'vnd.oma.bcast.drm-trigger+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.bcast.drm-trigger+xml'
	KMimeApplicationVndOmaBcastDrmTriggerXml Mime = "application/vnd.oma.bcast.drm-trigger+xml"

	// KMimeApplicationVndOmaBcastImdXml
	//
	// English:
	//
	//  Application type 'vnd.oma.bcast.imd+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.bcast.imd+xml'
	KMimeApplicationVndOmaBcastImdXml Mime = "application/vnd.oma.bcast.imd+xml"

	// KMimeApplicationVndOmaBcastLtkm
	//
	// English:
	//
	//  Application type 'vnd.oma.bcast.ltkm'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.bcast.ltkm'
	KMimeApplicationVndOmaBcastLtkm Mime = "application/vnd.oma.bcast.ltkm"

	// KMimeApplicationVndOmaBcastNotificationXml
	//
	// English:
	//
	//  Application type 'vnd.oma.bcast.notification+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.bcast.notification+xml'
	KMimeApplicationVndOmaBcastNotificationXml Mime = "application/vnd.oma.bcast.notification+xml"

	// KMimeApplicationVndOmaBcastProvisioningtrigger
	//
	// English:
	//
	//  Application type 'vnd.oma.bcast.provisioningtrigger'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.bcast.provisioningtrigger'
	KMimeApplicationVndOmaBcastProvisioningtrigger Mime = "application/vnd.oma.bcast.provisioningtrigger"

	// KMimeApplicationVndOmaBcastSgboot
	//
	// English:
	//
	//  Application type 'vnd.oma.bcast.sgboot'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.bcast.sgboot'
	KMimeApplicationVndOmaBcastSgboot Mime = "application/vnd.oma.bcast.sgboot"

	// KMimeApplicationVndOmaBcastSgddXml
	//
	// English:
	//
	//  Application type 'vnd.oma.bcast.sgdd+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.bcast.sgdd+xml'
	KMimeApplicationVndOmaBcastSgddXml Mime = "application/vnd.oma.bcast.sgdd+xml"

	// KMimeApplicationVndOmaBcastSgdu
	//
	// English:
	//
	//  Application type 'vnd.oma.bcast.sgdu'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.bcast.sgdu'
	KMimeApplicationVndOmaBcastSgdu Mime = "application/vnd.oma.bcast.sgdu"

	// KMimeApplicationVndOmaBcastSimpleSymbolContainer
	//
	// English:
	//
	//  Application type 'vnd.oma.bcast.simple-symbol-container'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.bcast.simple-symbol-container'
	KMimeApplicationVndOmaBcastSimpleSymbolContainer Mime = "application/vnd.oma.bcast.simple-symbol-container"

	// KMimeApplicationVndOmaBcastSmartcardTriggerXml
	//
	// English:
	//
	//  Application type 'vnd.oma.bcast.smartcard-trigger+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.bcast.smartcard-trigger+xml'
	KMimeApplicationVndOmaBcastSmartcardTriggerXml Mime = "application/vnd.oma.bcast.smartcard-trigger+xml"

	// KMimeApplicationVndOmaBcastSprovXml
	//
	// English:
	//
	//  Application type 'vnd.oma.bcast.sprov+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.bcast.sprov+xml'
	KMimeApplicationVndOmaBcastSprovXml Mime = "application/vnd.oma.bcast.sprov+xml"

	// KMimeApplicationVndOmaBcastStkm
	//
	// English:
	//
	//  Application type 'vnd.oma.bcast.stkm'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.bcast.stkm'
	KMimeApplicationVndOmaBcastStkm Mime = "application/vnd.oma.bcast.stkm"

	// KMimeApplicationVndOmaCabAddressBookXml
	//
	// English:
	//
	//  Application type 'vnd.oma.cab-address-book+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.cab-address-book+xml'
	KMimeApplicationVndOmaCabAddressBookXml Mime = "application/vnd.oma.cab-address-book+xml"

	// KMimeApplicationVndOmaCabFeatureHandlerXml
	//
	// English:
	//
	//  Application type 'vnd.oma.cab-feature-handler+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.cab-feature-handler+xml'
	KMimeApplicationVndOmaCabFeatureHandlerXml Mime = "application/vnd.oma.cab-feature-handler+xml"

	// KMimeApplicationVndOmaCabPccXml
	//
	// English:
	//
	//  Application type 'vnd.oma.cab-pcc+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.cab-pcc+xml'
	KMimeApplicationVndOmaCabPccXml Mime = "application/vnd.oma.cab-pcc+xml"

	// KMimeApplicationVndOmaCabSubsInviteXml
	//
	// English:
	//
	//  Application type 'vnd.oma.cab-subs-invite+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.cab-subs-invite+xml'
	KMimeApplicationVndOmaCabSubsInviteXml Mime = "application/vnd.oma.cab-subs-invite+xml"

	// KMimeApplicationVndOmaCabUserPrefsXml
	//
	// English:
	//
	//  Application type 'vnd.oma.cab-user-prefs+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.cab-user-prefs+xml'
	KMimeApplicationVndOmaCabUserPrefsXml Mime = "application/vnd.oma.cab-user-prefs+xml"

	// KMimeApplicationVndOmaDcd
	//
	// English:
	//
	//  Application type 'vnd.oma.dcd'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.dcd'
	KMimeApplicationVndOmaDcd Mime = "application/vnd.oma.dcd"

	// KMimeApplicationVndOmaDcdc
	//
	// English:
	//
	//  Application type 'vnd.oma.dcdc'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.dcdc'
	KMimeApplicationVndOmaDcdc Mime = "application/vnd.oma.dcdc"

	// KMimeApplicationVndOmaDd2Xml
	//
	// English:
	//
	//  Application type 'vnd.oma.dd2+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.dd2+xml'
	KMimeApplicationVndOmaDd2Xml Mime = "application/vnd.oma.dd2+xml"

	// KMimeApplicationVndOmaDrmRisdXml
	//
	// English:
	//
	//  Application type 'vnd.oma.drm.risd+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.drm.risd+xml'
	KMimeApplicationVndOmaDrmRisdXml Mime = "application/vnd.oma.drm.risd+xml"

	// KMimeApplicationVndOmaGroupUsageListXml
	//
	// English:
	//
	//  Application type 'vnd.oma.group-usage-list+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.group-usage-list+xml'
	KMimeApplicationVndOmaGroupUsageListXml Mime = "application/vnd.oma.group-usage-list+xml"

	// KMimeApplicationVndOmaLwm2mCbor
	//
	// English:
	//
	//  Application type 'vnd.oma.lwm2m+cbor'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.lwm2m+cbor'
	KMimeApplicationVndOmaLwm2mCbor Mime = "application/vnd.oma.lwm2m+cbor"

	// KMimeApplicationVndOmaLwm2mJson
	//
	// English:
	//
	//  Application type 'vnd.oma.lwm2m+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.lwm2m+json'
	KMimeApplicationVndOmaLwm2mJson Mime = "application/vnd.oma.lwm2m+json"

	// KMimeApplicationVndOmaLwm2mTlv
	//
	// English:
	//
	//  Application type 'vnd.oma.lwm2m+tlv'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.lwm2m+tlv'
	KMimeApplicationVndOmaLwm2mTlv Mime = "application/vnd.oma.lwm2m+tlv"

	// KMimeApplicationVndOmaPalXml
	//
	// English:
	//
	//  Application type 'vnd.oma.pal+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.pal+xml'
	KMimeApplicationVndOmaPalXml Mime = "application/vnd.oma.pal+xml"

	// KMimeApplicationVndOmaPocDetailedProgressReportXml
	//
	// English:
	//
	//  Application type 'vnd.oma.poc.detailed-progress-report+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.poc.detailed-progress-report+xml'
	KMimeApplicationVndOmaPocDetailedProgressReportXml Mime = "application/vnd.oma.poc.detailed-progress-report+xml"

	// KMimeApplicationVndOmaPocFinalReportXml
	//
	// English:
	//
	//  Application type 'vnd.oma.poc.final-report+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.poc.final-report+xml'
	KMimeApplicationVndOmaPocFinalReportXml Mime = "application/vnd.oma.poc.final-report+xml"

	// KMimeApplicationVndOmaPocGroupsXml
	//
	// English:
	//
	//  Application type 'vnd.oma.poc.groups+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.poc.groups+xml'
	KMimeApplicationVndOmaPocGroupsXml Mime = "application/vnd.oma.poc.groups+xml"

	// KMimeApplicationVndOmaPocInvocationDescriptorXml
	//
	// English:
	//
	//  Application type 'vnd.oma.poc.invocation-descriptor+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.poc.invocation-descriptor+xml'
	KMimeApplicationVndOmaPocInvocationDescriptorXml Mime = "application/vnd.oma.poc.invocation-descriptor+xml"

	// KMimeApplicationVndOmaPocOptimizedProgressReportXml
	//
	// English:
	//
	//  Application type 'vnd.oma.poc.optimized-progress-report+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.poc.optimized-progress-report+xml'
	KMimeApplicationVndOmaPocOptimizedProgressReportXml Mime = "application/vnd.oma.poc.optimized-progress-report+xml"

	// KMimeApplicationVndOmaPush
	//
	// English:
	//
	//  Application type 'vnd.oma.push'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.push'
	KMimeApplicationVndOmaPush Mime = "application/vnd.oma.push"

	// KMimeApplicationVndOmaScidmMessagesXml
	//
	// English:
	//
	//  Application type 'vnd.oma.scidm.messages+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.scidm.messages+xml'
	KMimeApplicationVndOmaScidmMessagesXml Mime = "application/vnd.oma.scidm.messages+xml"

	// KMimeApplicationVndOmaXcapDirectoryXml
	//
	// English:
	//
	//  Application type 'vnd.oma.xcap-directory+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.xcap-directory+xml'
	KMimeApplicationVndOmaXcapDirectoryXml Mime = "application/vnd.oma.xcap-directory+xml"

	// KMimeApplicationVndOmadsEmailXml
	//
	// English:
	//
	//  Application type 'vnd.omads-email+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.omads-email+xml'
	KMimeApplicationVndOmadsEmailXml Mime = "application/vnd.omads-email+xml"

	// KMimeApplicationVndOmadsFileXml
	//
	// English:
	//
	//  Application type 'vnd.omads-file+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.omads-file+xml'
	KMimeApplicationVndOmadsFileXml Mime = "application/vnd.omads-file+xml"

	// KMimeApplicationVndOmadsFolderXml
	//
	// English:
	//
	//  Application type 'vnd.omads-folder+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.omads-folder+xml'
	KMimeApplicationVndOmadsFolderXml Mime = "application/vnd.omads-folder+xml"

	// KMimeApplicationVndOmalocSuplInit
	//
	// English:
	//
	//  Application type 'vnd.omaloc-supl-init'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.omaloc-supl-init'
	KMimeApplicationVndOmalocSuplInit Mime = "application/vnd.omaloc-supl-init"

	// KMimeApplicationVndOmaScwsConfig
	//
	// English:
	//
	//  Application type 'vnd.oma-scws-config'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma-scws-config'
	KMimeApplicationVndOmaScwsConfig Mime = "application/vnd.oma-scws-config"

	// KMimeApplicationVndOmaScwsHttpRequest
	//
	// English:
	//
	//  Application type 'vnd.oma-scws-http-request'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma-scws-http-request'
	KMimeApplicationVndOmaScwsHttpRequest Mime = "application/vnd.oma-scws-http-request"

	// KMimeApplicationVndOmaScwsHttpResponse
	//
	// English:
	//
	//  Application type 'vnd.oma-scws-http-response'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma-scws-http-response'
	KMimeApplicationVndOmaScwsHttpResponse Mime = "application/vnd.oma-scws-http-response"

	// KMimeApplicationVndOnepager
	//
	// English:
	//
	//  Application type 'vnd.onepager'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.onepager'
	KMimeApplicationVndOnepager Mime = "application/vnd.onepager"

	// KMimeApplicationVndOnepagertamp
	//
	// English:
	//
	//  Application type 'vnd.onepagertamp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.onepagertamp'
	KMimeApplicationVndOnepagertamp Mime = "application/vnd.onepagertamp"

	// KMimeApplicationVndOnepagertamx
	//
	// English:
	//
	//  Application type 'vnd.onepagertamx'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.onepagertamx'
	KMimeApplicationVndOnepagertamx Mime = "application/vnd.onepagertamx"

	// KMimeApplicationVndOnepagertat
	//
	// English:
	//
	//  Application type 'vnd.onepagertat'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.onepagertat'
	KMimeApplicationVndOnepagertat Mime = "application/vnd.onepagertat"

	// KMimeApplicationVndOnepagertatp
	//
	// English:
	//
	//  Application type 'vnd.onepagertatp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.onepagertatp'
	KMimeApplicationVndOnepagertatp Mime = "application/vnd.onepagertatp"

	// KMimeApplicationVndOnepagertatx
	//
	// English:
	//
	//  Application type 'vnd.onepagertatx'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.onepagertatx'
	KMimeApplicationVndOnepagertatx Mime = "application/vnd.onepagertatx"

	// KMimeApplicationVndOnvifMetadata
	//
	// English:
	//
	//  Application type 'vnd.onvif.metadata'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.onvif.metadata'
	KMimeApplicationVndOnvifMetadata Mime = "application/vnd.onvif.metadata"

	// KMimeApplicationVndOpenbloxGameBinary
	//
	// English:
	//
	//  Application type 'vnd.openblox.game-binary'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openblox.game-binary'
	KMimeApplicationVndOpenbloxGameBinary Mime = "application/vnd.openblox.game-binary"

	// KMimeApplicationVndOpenbloxGameXml
	//
	// English:
	//
	//  Application type 'vnd.openblox.game+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openblox.game+xml'
	KMimeApplicationVndOpenbloxGameXml Mime = "application/vnd.openblox.game+xml"

	// KMimeApplicationVndOpeneyeOeb
	//
	// English:
	//
	//  Application type 'vnd.openeye.oeb'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openeye.oeb'
	KMimeApplicationVndOpeneyeOeb Mime = "application/vnd.openeye.oeb"

	// KMimeApplicationVndOpenstreetmapDataXml
	//
	// English:
	//
	//  Application type 'vnd.openstreetmap.data+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openstreetmap.data+xml'
	KMimeApplicationVndOpenstreetmapDataXml Mime = "application/vnd.openstreetmap.data+xml"

	// KMimeApplicationVndOpentimestampsOts
	//
	// English:
	//
	//  Application type 'vnd.opentimestamps.ots'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.opentimestamps.ots'
	KMimeApplicationVndOpentimestampsOts Mime = "application/vnd.opentimestamps.ots"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentCustomPropertiesXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.custom-properties+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.custom-properties+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentCustomPropertiesXml Mime = "application/vnd.openxmlformats-officedocument.custom-properties+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentCustomXmlPropertiesXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.customXmlProperties+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.customXmlProperties+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentCustomXmlPropertiesXml Mime = "application/vnd.openxmlformats-officedocument.customXmlProperties+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentDrawingXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.drawing+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.drawing+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentDrawingXml Mime = "application/vnd.openxmlformats-officedocument.drawing+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentDrawingmlChartXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.drawingml.chart+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.drawingml.chart+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentDrawingmlChartXml Mime = "application/vnd.openxmlformats-officedocument.drawingml.chart+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentDrawingmlChartshapesXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.drawingml.chartshapes+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.drawingml.chartshapes+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentDrawingmlChartshapesXml Mime = "application/vnd.openxmlformats-officedocument.drawingml.chartshapes+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentDrawingmlDiagramColorsXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.drawingml.diagramColors+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.drawingml.diagramColors+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentDrawingmlDiagramColorsXml Mime = "application/vnd.openxmlformats-officedocument.drawingml.diagramColors+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentDrawingmlDiagramDataXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.drawingml.diagramData+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.drawingml.diagramData+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentDrawingmlDiagramDataXml Mime = "application/vnd.openxmlformats-officedocument.drawingml.diagramData+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentDrawingmlDiagramLayoutXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.drawingml.diagramLayout+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.drawingml.diagramLayout+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentDrawingmlDiagramLayoutXml Mime = "application/vnd.openxmlformats-officedocument.drawingml.diagramLayout+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentDrawingmlDiagramStyleXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.drawingml.diagramStyle+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.drawingml.diagramStyle+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentDrawingmlDiagramStyleXml Mime = "application/vnd.openxmlformats-officedocument.drawingml.diagramStyle+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentExtendedPropertiesXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.extended-properties+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.extended-properties+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentExtendedPropertiesXml Mime = "application/vnd.openxmlformats-officedocument.extended-properties+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlCommentAuthorsXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.commentAuthors+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.commentAuthors+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlCommentAuthorsXml Mime = "application/vnd.openxmlformats-officedocument.presentationml.commentAuthors+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlCommentsXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.comments+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.comments+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlCommentsXml Mime = "application/vnd.openxmlformats-officedocument.presentationml.comments+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlHandoutMasterXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.handoutMaster+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.handoutMaster+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlHandoutMasterXml Mime = "application/vnd.openxmlformats-officedocument.presentationml.handoutMaster+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlNotesMasterXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.notesMaster+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.notesMaster+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlNotesMasterXml Mime = "application/vnd.openxmlformats-officedocument.presentationml.notesMaster+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlNotesSlideXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.notesSlide+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.notesSlide+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlNotesSlideXml Mime = "application/vnd.openxmlformats-officedocument.presentationml.notesSlide+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlPresentation
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.presentation'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.presentation'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlPresentation Mime = "application/vnd.openxmlformats-officedocument.presentationml.presentation"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlPresentationMainXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.presentation.main+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.presentation.main+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlPresentationMainXml Mime = "application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlPresPropsXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.presProps+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.presProps+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlPresPropsXml Mime = "application/vnd.openxmlformats-officedocument.presentationml.presProps+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlide
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.slide'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.slide'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlide Mime = "application/vnd.openxmlformats-officedocument.presentationml.slide"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlideXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.slide+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.slide+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlideXml Mime = "application/vnd.openxmlformats-officedocument.presentationml.slide+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlideLayoutXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.slideLayout+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.slideLayout+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlideLayoutXml Mime = "application/vnd.openxmlformats-officedocument.presentationml.slideLayout+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlideMasterXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.slideMaster+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.slideMaster+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlideMasterXml Mime = "application/vnd.openxmlformats-officedocument.presentationml.slideMaster+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlideshow
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.slideshow'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.slideshow'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlideshow Mime = "application/vnd.openxmlformats-officedocument.presentationml.slideshow"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlideshowMainXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlideshowMainXml Mime = "application/vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlideUpdateInfoXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.slideUpdateInfo+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.slideUpdateInfo+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlideUpdateInfoXml Mime = "application/vnd.openxmlformats-officedocument.presentationml.slideUpdateInfo+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlTableStylesXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.tableStyles+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.tableStyles+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlTableStylesXml Mime = "application/vnd.openxmlformats-officedocument.presentationml.tableStyles+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlTagsXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.tags+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.tags+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlTagsXml Mime = "application/vnd.openxmlformats-officedocument.presentationml.tags+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlTemplate
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.template'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.template'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlTemplate Mime = "application/vnd.openxmlformats-officedocument.presentationml.template"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlTemplateMainXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.template.main+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.template.main+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlTemplateMainXml Mime = "application/vnd.openxmlformats-officedocument.presentationml.template.main+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlViewPropsXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.viewProps+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.viewProps+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlViewPropsXml Mime = "application/vnd.openxmlformats-officedocument.presentationml.viewProps+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlCalcChainXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.calcChain+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.calcChain+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlCalcChainXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.calcChain+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlChartsheetXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.chartsheet+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.chartsheet+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlChartsheetXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.chartsheet+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlCommentsXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.comments+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.comments+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlCommentsXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlConnectionsXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.connections+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.connections+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlConnectionsXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.connections+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlDialogsheetXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.dialogsheet+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.dialogsheet+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlDialogsheetXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.dialogsheet+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlExternalLinkXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.externalLink+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.externalLink+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlExternalLinkXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.externalLink+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlPivotCacheDefinitionXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlPivotCacheDefinitionXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlPivotCacheRecordsXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheRecords+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheRecords+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlPivotCacheRecordsXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheRecords+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlPivotTableXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.pivotTable+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.pivotTable+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlPivotTableXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotTable+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlQueryTableXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.queryTable+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.queryTable+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlQueryTableXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.queryTable+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlRevisionHeadersXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.revisionHeaders+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.revisionHeaders+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlRevisionHeadersXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.revisionHeaders+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlRevisionLogXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.revisionLog+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.revisionLog+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlRevisionLogXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.revisionLog+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlSharedStringsXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlSharedStringsXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlSheet
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.sheet'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.sheet'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlSheet Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlSheetMainXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlSheetMainXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlSheetMetadataXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.sheetMetadata+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.sheetMetadata+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlSheetMetadataXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheetMetadata+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlStylesXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.styles+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.styles+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlStylesXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlTableXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.table+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.table+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlTableXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlTableSingleCellsXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.tableSingleCells+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.tableSingleCells+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlTableSingleCellsXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.tableSingleCells+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlTemplate
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.template'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.template'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlTemplate Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.template"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlTemplateMainXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlTemplateMainXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlUserNamesXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.userNames+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.userNames+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlUserNamesXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.userNames+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlVolatileDependenciesXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.volatileDependencies+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.volatileDependencies+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlVolatileDependenciesXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.volatileDependencies+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlWorksheetXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlWorksheetXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentThemeXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.theme+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.theme+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentThemeXml Mime = "application/vnd.openxmlformats-officedocument.theme+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentThemeOverrideXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.themeOverride+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.themeOverride+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentThemeOverrideXml Mime = "application/vnd.openxmlformats-officedocument.themeOverride+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentVmlDrawing
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.vmlDrawing'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.vmlDrawing'
	KMimeApplicationVndOpenxmlformatsOfficedocumentVmlDrawing Mime = "application/vnd.openxmlformats-officedocument.vmlDrawing"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlCommentsXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.wordprocessingml.comments+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.wordprocessingml.comments+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlCommentsXml Mime = "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlDocument
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.wordprocessingml.document'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.wordprocessingml.document'
	KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlDocument Mime = "application/vnd.openxmlformats-officedocument.wordprocessingml.document"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlDocumentGlossaryXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.wordprocessingml.document.glossary+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.wordprocessingml.document.glossary+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlDocumentGlossaryXml Mime = "application/vnd.openxmlformats-officedocument.wordprocessingml.document.glossary+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlDocumentMainXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlDocumentMainXml Mime = "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlEndnotesXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlEndnotesXml Mime = "application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlFontTableXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.wordprocessingml.fontTable+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.wordprocessingml.fontTable+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlFontTableXml Mime = "application/vnd.openxmlformats-officedocument.wordprocessingml.fontTable+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlFooterXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.wordprocessingml.footer+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.wordprocessingml.footer+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlFooterXml Mime = "application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlFootnotesXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlFootnotesXml Mime = "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlNumberingXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlNumberingXml Mime = "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlSettingsXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.wordprocessingml.settings+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.wordprocessingml.settings+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlSettingsXml Mime = "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlStylesXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.wordprocessingml.styles+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.wordprocessingml.styles+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlStylesXml Mime = "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlTemplate
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.wordprocessingml.template'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.wordprocessingml.template'
	KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlTemplate Mime = "application/vnd.openxmlformats-officedocument.wordprocessingml.template"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlTemplateMainXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlTemplateMainXml Mime = "application/vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlWebSettingsXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.wordprocessingml.webSettings+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.wordprocessingml.webSettings+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlWebSettingsXml Mime = "application/vnd.openxmlformats-officedocument.wordprocessingml.webSettings+xml"

	// KMimeApplicationVndOpenxmlformatsPackageCorePropertiesXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-package.core-properties+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-package.core-properties+xml'
	KMimeApplicationVndOpenxmlformatsPackageCorePropertiesXml Mime = "application/vnd.openxmlformats-package.core-properties+xml"

	// KMimeApplicationVndOpenxmlformatsPackageDigitalSignatureXmlsignatureXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-package.digital-signature-xmlsignature+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-package.digital-signature-xmlsignature+xml'
	KMimeApplicationVndOpenxmlformatsPackageDigitalSignatureXmlsignatureXml Mime = "application/vnd.openxmlformats-package.digital-signature-xmlsignature+xml"

	// KMimeApplicationVndOpenxmlformatsPackageRelationshipsXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-package.relationships+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-package.relationships+xml'
	KMimeApplicationVndOpenxmlformatsPackageRelationshipsXml Mime = "application/vnd.openxmlformats-package.relationships+xml"

	// KMimeApplicationVndOracleResourceJson
	//
	// English:
	//
	//  Application type 'vnd.oracle.resource+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oracle.resource+json'
	KMimeApplicationVndOracleResourceJson Mime = "application/vnd.oracle.resource+json"

	// KMimeApplicationVndOrangeIndata
	//
	// English:
	//
	//  Application type 'vnd.orange.indata'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.orange.indata'
	KMimeApplicationVndOrangeIndata Mime = "application/vnd.orange.indata"

	// KMimeApplicationVndOsaNetdeploy
	//
	// English:
	//
	//  Application type 'vnd.osa.netdeploy'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.osa.netdeploy'
	KMimeApplicationVndOsaNetdeploy Mime = "application/vnd.osa.netdeploy"

	// KMimeApplicationVndOsgeoMapguidePackage
	//
	// English:
	//
	//  Application type 'vnd.osgeo.mapguide.package'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.osgeo.mapguide.package'
	KMimeApplicationVndOsgeoMapguidePackage Mime = "application/vnd.osgeo.mapguide.package"

	// KMimeApplicationVndOsgiBundle
	//
	// English:
	//
	//  Application type 'vnd.osgi.bundle'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.osgi.bundle'
	KMimeApplicationVndOsgiBundle Mime = "application/vnd.osgi.bundle"

	// KMimeApplicationVndOsgiDp
	//
	// English:
	//
	//  Application type 'vnd.osgi.dp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.osgi.dp'
	KMimeApplicationVndOsgiDp Mime = "application/vnd.osgi.dp"

	// KMimeApplicationVndOsgiSubsystem
	//
	// English:
	//
	//  Application type 'vnd.osgi.subsystem'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.osgi.subsystem'
	KMimeApplicationVndOsgiSubsystem Mime = "application/vnd.osgi.subsystem"

	// KMimeApplicationVndOtpsCtKipXml
	//
	// English:
	//
	//  Application type 'vnd.otps.ct-kip+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.otps.ct-kip+xml'
	KMimeApplicationVndOtpsCtKipXml Mime = "application/vnd.otps.ct-kip+xml"

	// KMimeApplicationVndOxliCountgraph
	//
	// English:
	//
	//  Application type 'vnd.oxli.countgraph'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oxli.countgraph'
	KMimeApplicationVndOxliCountgraph Mime = "application/vnd.oxli.countgraph"

	// KMimeApplicationVndPagerdutyJson
	//
	// English:
	//
	//  Application type 'vnd.pagerduty+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.pagerduty+json'
	KMimeApplicationVndPagerdutyJson Mime = "application/vnd.pagerduty+json"

	// KMimeApplicationVndPalm
	//
	// English:
	//
	//  Application type 'vnd.palm'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.palm'
	KMimeApplicationVndPalm Mime = "application/vnd.palm"

	// KMimeApplicationVndPanoply
	//
	// English:
	//
	//  Application type 'vnd.panoply'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.panoply'
	KMimeApplicationVndPanoply Mime = "application/vnd.panoply"

	// KMimeApplicationVndPaosXml
	//
	// English:
	//
	//  Application type 'vnd.paos.xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.paos.xml'
	KMimeApplicationVndPaosXml Mime = "application/vnd.paos.xml"

	// KMimeApplicationVndPatentdive
	//
	// English:
	//
	//  Application type 'vnd.patentdive'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.patentdive'
	KMimeApplicationVndPatentdive Mime = "application/vnd.patentdive"

	// KMimeApplicationVndPatientecommsdoc
	//
	// English:
	//
	//  Application type 'vnd.patientecommsdoc'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.patientecommsdoc'
	KMimeApplicationVndPatientecommsdoc Mime = "application/vnd.patientecommsdoc"

	// KMimeApplicationVndPawaafile
	//
	// English:
	//
	//  Application type 'vnd.pawaafile'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.pawaafile'
	KMimeApplicationVndPawaafile Mime = "application/vnd.pawaafile"

	// KMimeApplicationVndPcos
	//
	// English:
	//
	//  Application type 'vnd.pcos'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.pcos'
	KMimeApplicationVndPcos Mime = "application/vnd.pcos"

	// KMimeApplicationVndPgFormat
	//
	// English:
	//
	//  Application type 'vnd.pg.format'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.pg.format'
	KMimeApplicationVndPgFormat Mime = "application/vnd.pg.format"

	// KMimeApplicationVndPgOsasli
	//
	// English:
	//
	//  Application type 'vnd.pg.osasli'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.pg.osasli'
	KMimeApplicationVndPgOsasli Mime = "application/vnd.pg.osasli"

	// KMimeApplicationVndPiaccessApplicationLicence
	//
	// English:
	//
	//  Application type 'vnd.piaccess.application-licence'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.piaccess.application-licence'
	KMimeApplicationVndPiaccessApplicationLicence Mime = "application/vnd.piaccess.application-licence"

	// KMimeApplicationVndPicsel
	//
	// English:
	//
	//  Application type 'vnd.picsel'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.picsel'
	KMimeApplicationVndPicsel Mime = "application/vnd.picsel"

	// KMimeApplicationVndPmiWidget
	//
	// English:
	//
	//  Application type 'vnd.pmi.widget'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.pmi.widget'
	KMimeApplicationVndPmiWidget Mime = "application/vnd.pmi.widget"

	// KMimeApplicationVndPocGroupAdvertisementXml
	//
	// English:
	//
	//  Application type 'vnd.poc.group-advertisement+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.poc.group-advertisement+xml'
	KMimeApplicationVndPocGroupAdvertisementXml Mime = "application/vnd.poc.group-advertisement+xml"

	// KMimeApplicationVndPocketlearn
	//
	// English:
	//
	//  Application type 'vnd.pocketlearn'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.pocketlearn'
	KMimeApplicationVndPocketlearn Mime = "application/vnd.pocketlearn"

	// KMimeApplicationVndPowerbuilder6
	//
	// English:
	//
	//  Application type 'vnd.powerbuilder6'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.powerbuilder6'
	KMimeApplicationVndPowerbuilder6 Mime = "application/vnd.powerbuilder6"

	// KMimeApplicationVndPowerbuilder6S
	//
	// English:
	//
	//  Application type 'vnd.powerbuilder6-s'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.powerbuilder6-s'
	KMimeApplicationVndPowerbuilder6S Mime = "application/vnd.powerbuilder6-s"

	// KMimeApplicationVndPowerbuilder7
	//
	// English:
	//
	//  Application type 'vnd.powerbuilder7'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.powerbuilder7'
	KMimeApplicationVndPowerbuilder7 Mime = "application/vnd.powerbuilder7"

	// KMimeApplicationVndPowerbuilder75
	//
	// English:
	//
	//  Application type 'vnd.powerbuilder75'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.powerbuilder75'
	KMimeApplicationVndPowerbuilder75 Mime = "application/vnd.powerbuilder75"

	// KMimeApplicationVndPowerbuilder75S
	//
	// English:
	//
	//  Application type 'vnd.powerbuilder75-s'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.powerbuilder75-s'
	KMimeApplicationVndPowerbuilder75S Mime = "application/vnd.powerbuilder75-s"

	// KMimeApplicationVndPowerbuilder7S
	//
	// English:
	//
	//  Application type 'vnd.powerbuilder7-s'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.powerbuilder7-s'
	KMimeApplicationVndPowerbuilder7S Mime = "application/vnd.powerbuilder7-s"

	// KMimeApplicationVndPreminet
	//
	// English:
	//
	//  Application type 'vnd.preminet'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.preminet'
	KMimeApplicationVndPreminet Mime = "application/vnd.preminet"

	// KMimeApplicationVndPreviewsystemsBox
	//
	// English:
	//
	//  Application type 'vnd.previewsystems.box'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.previewsystems.box'
	KMimeApplicationVndPreviewsystemsBox Mime = "application/vnd.previewsystems.box"

	// KMimeApplicationVndProteusMagazine
	//
	// English:
	//
	//  Application type 'vnd.proteus.magazine'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.proteus.magazine'
	KMimeApplicationVndProteusMagazine Mime = "application/vnd.proteus.magazine"

	// KMimeApplicationVndPsfs
	//
	// English:
	//
	//  Application type 'vnd.psfs'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.psfs'
	KMimeApplicationVndPsfs Mime = "application/vnd.psfs"

	// KMimeApplicationVndPublishareDeltaTree
	//
	// English:
	//
	//  Application type 'vnd.publishare-delta-tree'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.publishare-delta-tree'
	KMimeApplicationVndPublishareDeltaTree Mime = "application/vnd.publishare-delta-tree"

	// KMimeApplicationVndPviPtid1
	//
	// English:
	//
	//  Application type 'vnd.pvi.ptid1'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.pvi.ptid1'
	KMimeApplicationVndPviPtid1 Mime = "application/vnd.pvi.ptid1"

	// KMimeApplicationVndPwgMultiplexed
	//
	// English:
	//
	//  Application type 'vnd.pwg-multiplexed'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.pwg-multiplexed'
	KMimeApplicationVndPwgMultiplexed Mime = "application/vnd.pwg-multiplexed"

	// KMimeApplicationVndPwgXhtmlPrintXml
	//
	// English:
	//
	//  Application type 'vnd.pwg-xhtml-print+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.pwg-xhtml-print+xml'
	KMimeApplicationVndPwgXhtmlPrintXml Mime = "application/vnd.pwg-xhtml-print+xml"

	// KMimeApplicationVndQualcommBrewAppRes
	//
	// English:
	//
	//  Application type 'vnd.qualcomm.brew-app-res'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.qualcomm.brew-app-res'
	KMimeApplicationVndQualcommBrewAppRes Mime = "application/vnd.qualcomm.brew-app-res"

	// KMimeApplicationVndQuarantainenet
	//
	// English:
	//
	//  Application type 'vnd.quarantainenet'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.quarantainenet'
	KMimeApplicationVndQuarantainenet Mime = "application/vnd.quarantainenet"

	// KMimeApplicationVndQuarkQuarkXPress
	//
	// English:
	//
	//  Application type 'vnd.Quark.QuarkXPress'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.Quark.QuarkXPress'
	KMimeApplicationVndQuarkQuarkXPress Mime = "application/vnd.Quark.QuarkXPress"

	// KMimeApplicationVndQuobjectQuoxdocument
	//
	// English:
	//
	//  Application type 'vnd.quobject-quoxdocument'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.quobject-quoxdocument'
	KMimeApplicationVndQuobjectQuoxdocument Mime = "application/vnd.quobject-quoxdocument"

	// KMimeApplicationVndRadisysMomlXml
	//
	// English:
	//
	//  Application type 'vnd.radisys.moml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.radisys.moml+xml'
	KMimeApplicationVndRadisysMomlXml Mime = "application/vnd.radisys.moml+xml"

	// KMimeApplicationVndRadisysMsmlAuditConfXml
	//
	// English:
	//
	//  Application type 'vnd.radisys.msml-audit-conf+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.radisys.msml-audit-conf+xml'
	KMimeApplicationVndRadisysMsmlAuditConfXml Mime = "application/vnd.radisys.msml-audit-conf+xml"

	// KMimeApplicationVndRadisysMsmlAuditConnXml
	//
	// English:
	//
	//  Application type 'vnd.radisys.msml-audit-conn+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.radisys.msml-audit-conn+xml'
	KMimeApplicationVndRadisysMsmlAuditConnXml Mime = "application/vnd.radisys.msml-audit-conn+xml"

	// KMimeApplicationVndRadisysMsmlAuditDialogXml
	//
	// English:
	//
	//  Application type 'vnd.radisys.msml-audit-dialog+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.radisys.msml-audit-dialog+xml'
	KMimeApplicationVndRadisysMsmlAuditDialogXml Mime = "application/vnd.radisys.msml-audit-dialog+xml"

	// KMimeApplicationVndRadisysMsmlAuditStreamXml
	//
	// English:
	//
	//  Application type 'vnd.radisys.msml-audit-stream+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.radisys.msml-audit-stream+xml'
	KMimeApplicationVndRadisysMsmlAuditStreamXml Mime = "application/vnd.radisys.msml-audit-stream+xml"

	// KMimeApplicationVndRadisysMsmlAuditXml
	//
	// English:
	//
	//  Application type 'vnd.radisys.msml-audit+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.radisys.msml-audit+xml'
	KMimeApplicationVndRadisysMsmlAuditXml Mime = "application/vnd.radisys.msml-audit+xml"

	// KMimeApplicationVndRadisysMsmlConfXml
	//
	// English:
	//
	//  Application type 'vnd.radisys.msml-conf+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.radisys.msml-conf+xml'
	KMimeApplicationVndRadisysMsmlConfXml Mime = "application/vnd.radisys.msml-conf+xml"

	// KMimeApplicationVndRadisysMsmlDialogBaseXml
	//
	// English:
	//
	//  Application type 'vnd.radisys.msml-dialog-base+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.radisys.msml-dialog-base+xml'
	KMimeApplicationVndRadisysMsmlDialogBaseXml Mime = "application/vnd.radisys.msml-dialog-base+xml"

	// KMimeApplicationVndRadisysMsmlDialogFaxDetectXml
	//
	// English:
	//
	//  Application type 'vnd.radisys.msml-dialog-fax-detect+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.radisys.msml-dialog-fax-detect+xml'
	KMimeApplicationVndRadisysMsmlDialogFaxDetectXml Mime = "application/vnd.radisys.msml-dialog-fax-detect+xml"

	// KMimeApplicationVndRadisysMsmlDialogFaxSendrecvXml
	//
	// English:
	//
	//  Application type 'vnd.radisys.msml-dialog-fax-sendrecv+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.radisys.msml-dialog-fax-sendrecv+xml'
	KMimeApplicationVndRadisysMsmlDialogFaxSendrecvXml Mime = "application/vnd.radisys.msml-dialog-fax-sendrecv+xml"

	// KMimeApplicationVndRadisysMsmlDialogGroupXml
	//
	// English:
	//
	//  Application type 'vnd.radisys.msml-dialog-group+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.radisys.msml-dialog-group+xml'
	KMimeApplicationVndRadisysMsmlDialogGroupXml Mime = "application/vnd.radisys.msml-dialog-group+xml"

	// KMimeApplicationVndRadisysMsmlDialogSpeechXml
	//
	// English:
	//
	//  Application type 'vnd.radisys.msml-dialog-speech+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.radisys.msml-dialog-speech+xml'
	KMimeApplicationVndRadisysMsmlDialogSpeechXml Mime = "application/vnd.radisys.msml-dialog-speech+xml"

	// KMimeApplicationVndRadisysMsmlDialogTransformXml
	//
	// English:
	//
	//  Application type 'vnd.radisys.msml-dialog-transform+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.radisys.msml-dialog-transform+xml'
	KMimeApplicationVndRadisysMsmlDialogTransformXml Mime = "application/vnd.radisys.msml-dialog-transform+xml"

	// KMimeApplicationVndRadisysMsmlDialogXml
	//
	// English:
	//
	//  Application type 'vnd.radisys.msml-dialog+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.radisys.msml-dialog+xml'
	KMimeApplicationVndRadisysMsmlDialogXml Mime = "application/vnd.radisys.msml-dialog+xml"

	// KMimeApplicationVndRadisysMsmlXml
	//
	// English:
	//
	//  Application type 'vnd.radisys.msml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.radisys.msml+xml'
	KMimeApplicationVndRadisysMsmlXml Mime = "application/vnd.radisys.msml+xml"

	// KMimeApplicationVndRainstorData
	//
	// English:
	//
	//  Application type 'vnd.rainstor.data'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.rainstor.data'
	KMimeApplicationVndRainstorData Mime = "application/vnd.rainstor.data"

	// KMimeApplicationVndRapid
	//
	// English:
	//
	//  Application type 'vnd.rapid'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.rapid'
	KMimeApplicationVndRapid Mime = "application/vnd.rapid"

	// KMimeApplicationVndRar
	//
	// English:
	//
	//  Application type 'vnd.rar'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.rar'
	KMimeApplicationVndRar Mime = "application/vnd.rar"

	// KMimeApplicationVndRealvncBed
	//
	// English:
	//
	//  Application type 'vnd.realvnc.bed'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.realvnc.bed'
	KMimeApplicationVndRealvncBed Mime = "application/vnd.realvnc.bed"

	// KMimeApplicationVndRecordareMusicxml
	//
	// English:
	//
	//  Application type 'vnd.recordare.musicxml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.recordare.musicxml'
	KMimeApplicationVndRecordareMusicxml Mime = "application/vnd.recordare.musicxml"

	// KMimeApplicationVndRecordareMusicxmlXml
	//
	// English:
	//
	//  Application type 'vnd.recordare.musicxml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.recordare.musicxml+xml'
	KMimeApplicationVndRecordareMusicxmlXml Mime = "application/vnd.recordare.musicxml+xml"

	// KMimeApplicationVndRenLearnRlprint
	//
	// English:
	//
	//  Application type 'vnd.RenLearn.rlprint'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.RenLearn.rlprint'
	KMimeApplicationVndRenLearnRlprint Mime = "application/vnd.RenLearn.rlprint"

	// KMimeApplicationVndResilientLogic
	//
	// English:
	//
	//  Application type 'vnd.resilient.logic'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.resilient.logic'
	KMimeApplicationVndResilientLogic Mime = "application/vnd.resilient.logic"

	// KMimeApplicationVndRestfulJson
	//
	// English:
	//
	//  Application type 'vnd.restful+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.restful+json'
	KMimeApplicationVndRestfulJson Mime = "application/vnd.restful+json"

	// KMimeApplicationVndRigCryptonote
	//
	// English:
	//
	//  Application type 'vnd.rig.cryptonote'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.rig.cryptonote'
	KMimeApplicationVndRigCryptonote Mime = "application/vnd.rig.cryptonote"

	// KMimeApplicationVndRoute66Link66Xml
	//
	// English:
	//
	//  Application type 'vnd.route66.link66+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.route66.link66+xml'
	KMimeApplicationVndRoute66Link66Xml Mime = "application/vnd.route66.link66+xml"

	// KMimeApplicationVndRs274x
	//
	// English:
	//
	//  Application type 'vnd.rs-274x'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.rs-274x'
	KMimeApplicationVndRs274x Mime = "application/vnd.rs-274x"

	// KMimeApplicationVndRuckusDownload
	//
	// English:
	//
	//  Application type 'vnd.ruckus.download'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ruckus.download'
	KMimeApplicationVndRuckusDownload Mime = "application/vnd.ruckus.download"

	// KMimeApplicationVndS3sms
	//
	// English:
	//
	//  Application type 'vnd.s3sms'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.s3sms'
	KMimeApplicationVndS3sms Mime = "application/vnd.s3sms"

	// KMimeApplicationVndSailingtrackerTrack
	//
	// English:
	//
	//  Application type 'vnd.sailingtracker.track'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sailingtracker.track'
	KMimeApplicationVndSailingtrackerTrack Mime = "application/vnd.sailingtracker.track"

	// KMimeApplicationVndSar
	//
	// English:
	//
	//  Application type 'vnd.sar'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sar'
	KMimeApplicationVndSar Mime = "application/vnd.sar"

	// KMimeApplicationVndSbmCid
	//
	// English:
	//
	//  Application type 'vnd.sbm.cid'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sbm.cid'
	KMimeApplicationVndSbmCid Mime = "application/vnd.sbm.cid"

	// KMimeApplicationVndSbmMid2
	//
	// English:
	//
	//  Application type 'vnd.sbm.mid2'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sbm.mid2'
	KMimeApplicationVndSbmMid2 Mime = "application/vnd.sbm.mid2"

	// KMimeApplicationVndScribus
	//
	// English:
	//
	//  Application type 'vnd.scribus'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.scribus'
	KMimeApplicationVndScribus Mime = "application/vnd.scribus"

	// KMimeApplicationVndSealed3df
	//
	// English:
	//
	//  Application type 'vnd.sealed.3df'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sealed.3df'
	KMimeApplicationVndSealed3df Mime = "application/vnd.sealed.3df"

	// KMimeApplicationVndSealedCsf
	//
	// English:
	//
	//  Application type 'vnd.sealed.csf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sealed.csf'
	KMimeApplicationVndSealedCsf Mime = "application/vnd.sealed.csf"

	// KMimeApplicationVndSealedDoc
	//
	// English:
	//
	//  Application type 'vnd.sealed.doc'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sealed.doc'
	KMimeApplicationVndSealedDoc Mime = "application/vnd.sealed.doc"

	// KMimeApplicationVndSealedEml
	//
	// English:
	//
	//  Application type 'vnd.sealed.eml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sealed.eml'
	KMimeApplicationVndSealedEml Mime = "application/vnd.sealed.eml"

	// KMimeApplicationVndSealedMht
	//
	// English:
	//
	//  Application type 'vnd.sealed.mht'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sealed.mht'
	KMimeApplicationVndSealedMht Mime = "application/vnd.sealed.mht"

	// KMimeApplicationVndSealedNet
	//
	// English:
	//
	//  Application type 'vnd.sealed.net'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sealed.net'
	KMimeApplicationVndSealedNet Mime = "application/vnd.sealed.net"

	// KMimeApplicationVndSealedPpt
	//
	// English:
	//
	//  Application type 'vnd.sealed.ppt'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sealed.ppt'
	KMimeApplicationVndSealedPpt Mime = "application/vnd.sealed.ppt"

	// KMimeApplicationVndSealedTiff
	//
	// English:
	//
	//  Application type 'vnd.sealed.tiff'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sealed.tiff'
	KMimeApplicationVndSealedTiff Mime = "application/vnd.sealed.tiff"

	// KMimeApplicationVndSealedXls
	//
	// English:
	//
	//  Application type 'vnd.sealed.xls'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sealed.xls'
	KMimeApplicationVndSealedXls Mime = "application/vnd.sealed.xls"

	// KMimeApplicationVndSealedmediaSoftsealHtml
	//
	// English:
	//
	//  Application type 'vnd.sealedmedia.softseal.html'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sealedmedia.softseal.html'
	KMimeApplicationVndSealedmediaSoftsealHtml Mime = "application/vnd.sealedmedia.softseal.html"

	// KMimeApplicationVndSealedmediaSoftsealPdf
	//
	// English:
	//
	//  Application type 'vnd.sealedmedia.softseal.pdf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sealedmedia.softseal.pdf'
	KMimeApplicationVndSealedmediaSoftsealPdf Mime = "application/vnd.sealedmedia.softseal.pdf"

	// KMimeApplicationVndSeemail
	//
	// English:
	//
	//  Application type 'vnd.seemail'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.seemail'
	KMimeApplicationVndSeemail Mime = "application/vnd.seemail"

	// KMimeApplicationVndSeisJson
	//
	// English:
	//
	//  Application type 'vnd.seis+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.seis+json'
	KMimeApplicationVndSeisJson Mime = "application/vnd.seis+json"

	// KMimeApplicationVndSema
	//
	// English:
	//
	//  Application type 'vnd.sema'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sema'
	KMimeApplicationVndSema Mime = "application/vnd.sema"

	// KMimeApplicationVndSemd
	//
	// English:
	//
	//  Application type 'vnd.semd'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.semd'
	KMimeApplicationVndSemd Mime = "application/vnd.semd"

	// KMimeApplicationVndSemf
	//
	// English:
	//
	//  Application type 'vnd.semf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.semf'
	KMimeApplicationVndSemf Mime = "application/vnd.semf"

	// KMimeApplicationVndShadeSaveFile
	//
	// English:
	//
	//  Application type 'vnd.shade-save-file'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.shade-save-file'
	KMimeApplicationVndShadeSaveFile Mime = "application/vnd.shade-save-file"

	// KMimeApplicationVndShanaInformedFormdata
	//
	// English:
	//
	//  Application type 'vnd.shana.informed.formdata'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.shana.informed.formdata'
	KMimeApplicationVndShanaInformedFormdata Mime = "application/vnd.shana.informed.formdata"

	// KMimeApplicationVndShanaInformedFormtemplate
	//
	// English:
	//
	//  Application type 'vnd.shana.informed.formtemplate'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.shana.informed.formtemplate'
	KMimeApplicationVndShanaInformedFormtemplate Mime = "application/vnd.shana.informed.formtemplate"

	// KMimeApplicationVndShanaInformedInterchange
	//
	// English:
	//
	//  Application type 'vnd.shana.informed.interchange'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.shana.informed.interchange'
	KMimeApplicationVndShanaInformedInterchange Mime = "application/vnd.shana.informed.interchange"

	// KMimeApplicationVndShanaInformedPackage
	//
	// English:
	//
	//  Application type 'vnd.shana.informed.package'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.shana.informed.package'
	KMimeApplicationVndShanaInformedPackage Mime = "application/vnd.shana.informed.package"

	// KMimeApplicationVndShootproofJson
	//
	// English:
	//
	//  Application type 'vnd.shootproof+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.shootproof+json'
	KMimeApplicationVndShootproofJson Mime = "application/vnd.shootproof+json"

	// KMimeApplicationVndShopkickJson
	//
	// English:
	//
	//  Application type 'vnd.shopkick+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.shopkick+json'
	KMimeApplicationVndShopkickJson Mime = "application/vnd.shopkick+json"

	// KMimeApplicationVndShp
	//
	// English:
	//
	//  Application type 'vnd.shp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.shp'
	KMimeApplicationVndShp Mime = "application/vnd.shp"

	// KMimeApplicationVndShx
	//
	// English:
	//
	//  Application type 'vnd.shx'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.shx'
	KMimeApplicationVndShx Mime = "application/vnd.shx"

	// KMimeApplicationVndSigrokSession
	//
	// English:
	//
	//  Application type 'vnd.sigrok.session'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sigrok.session'
	KMimeApplicationVndSigrokSession Mime = "application/vnd.sigrok.session"

	// KMimeApplicationVndSimTechMindMapper
	//
	// English:
	//
	//  Application type 'vnd.SimTech-MindMapper'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.SimTech-MindMapper'
	KMimeApplicationVndSimTechMindMapper Mime = "application/vnd.SimTech-MindMapper"

	// KMimeApplicationVndSirenJson
	//
	// English:
	//
	//  Application type 'vnd.siren+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.siren+json'
	KMimeApplicationVndSirenJson Mime = "application/vnd.siren+json"

	// KMimeApplicationVndSmaf
	//
	// English:
	//
	//  Application type 'vnd.smaf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.smaf'
	KMimeApplicationVndSmaf Mime = "application/vnd.smaf"

	// KMimeApplicationVndSmartNotebook
	//
	// English:
	//
	//  Application type 'vnd.smart.notebook'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.smart.notebook'
	KMimeApplicationVndSmartNotebook Mime = "application/vnd.smart.notebook"

	// KMimeApplicationVndSmartTeacher
	//
	// English:
	//
	//  Application type 'vnd.smart.teacher'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.smart.teacher'
	KMimeApplicationVndSmartTeacher Mime = "application/vnd.smart.teacher"

	// KMimeApplicationVndSnesdevPageTable
	//
	// English:
	//
	//  Application type 'vnd.snesdev-page-table'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.snesdev-page-table'
	KMimeApplicationVndSnesdevPageTable Mime = "application/vnd.snesdev-page-table"

	// KMimeApplicationVndSoftware602FillerFormXml
	//
	// English:
	//
	//  Application type 'vnd.software602.filler.form+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.software602.filler.form+xml'
	KMimeApplicationVndSoftware602FillerFormXml Mime = "application/vnd.software602.filler.form+xml"

	// KMimeApplicationVndSoftware602FillerFormXmlZip
	//
	// English:
	//
	//  Application type 'vnd.software602.filler.form-xml-zip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.software602.filler.form-xml-zip'
	KMimeApplicationVndSoftware602FillerFormXmlZip Mime = "application/vnd.software602.filler.form-xml-zip"

	// KMimeApplicationVndSolentSdkmXml
	//
	// English:
	//
	//  Application type 'vnd.solent.sdkm+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.solent.sdkm+xml'
	KMimeApplicationVndSolentSdkmXml Mime = "application/vnd.solent.sdkm+xml"

	// KMimeApplicationVndSpotfireDxp
	//
	// English:
	//
	//  Application type 'vnd.spotfire.dxp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.spotfire.dxp'
	KMimeApplicationVndSpotfireDxp Mime = "application/vnd.spotfire.dxp"

	// KMimeApplicationVndSpotfireSfs
	//
	// English:
	//
	//  Application type 'vnd.spotfire.sfs'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.spotfire.sfs'
	KMimeApplicationVndSpotfireSfs Mime = "application/vnd.spotfire.sfs"

	// KMimeApplicationVndSqlite3
	//
	// English:
	//
	//  Application type 'vnd.sqlite3'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sqlite3'
	KMimeApplicationVndSqlite3 Mime = "application/vnd.sqlite3"

	// KMimeApplicationVndSssCod
	//
	// English:
	//
	//  Application type 'vnd.sss-cod'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sss-cod'
	KMimeApplicationVndSssCod Mime = "application/vnd.sss-cod"

	// KMimeApplicationVndSssDtf
	//
	// English:
	//
	//  Application type 'vnd.sss-dtf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sss-dtf'
	KMimeApplicationVndSssDtf Mime = "application/vnd.sss-dtf"

	// KMimeApplicationVndSssNtf
	//
	// English:
	//
	//  Application type 'vnd.sss-ntf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sss-ntf'
	KMimeApplicationVndSssNtf Mime = "application/vnd.sss-ntf"

	// KMimeApplicationVndStepmaniaPackage
	//
	// English:
	//
	//  Application type 'vnd.stepmania.package'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.stepmania.package'
	KMimeApplicationVndStepmaniaPackage Mime = "application/vnd.stepmania.package"

	// KMimeApplicationVndStepmaniaStepchart
	//
	// English:
	//
	//  Application type 'vnd.stepmania.stepchart'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.stepmania.stepchart'
	KMimeApplicationVndStepmaniaStepchart Mime = "application/vnd.stepmania.stepchart"

	// KMimeApplicationVndStreetStream
	//
	// English:
	//
	//  Application type 'vnd.street-stream'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.street-stream'
	KMimeApplicationVndStreetStream Mime = "application/vnd.street-stream"

	// KMimeApplicationVndSunWadlXml
	//
	// English:
	//
	//  Application type 'vnd.sun.wadl+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sun.wadl+xml'
	KMimeApplicationVndSunWadlXml Mime = "application/vnd.sun.wadl+xml"

	// KMimeApplicationVndSusCalendar
	//
	// English:
	//
	//  Application type 'vnd.sus-calendar'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sus-calendar'
	KMimeApplicationVndSusCalendar Mime = "application/vnd.sus-calendar"

	// KMimeApplicationVndSvd
	//
	// English:
	//
	//  Application type 'vnd.svd'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.svd'
	KMimeApplicationVndSvd Mime = "application/vnd.svd"

	// KMimeApplicationVndSwiftviewIcs
	//
	// English:
	//
	//  Application type 'vnd.swiftview-ics'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.swiftview-ics'
	KMimeApplicationVndSwiftviewIcs Mime = "application/vnd.swiftview-ics"

	// KMimeApplicationVndSycleXml
	//
	// English:
	//
	//  Application type 'vnd.sycle+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sycle+xml'
	KMimeApplicationVndSycleXml Mime = "application/vnd.sycle+xml"

	// KMimeApplicationVndSyftJson
	//
	// English:
	//
	//  Application type 'vnd.syft+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.syft+json'
	KMimeApplicationVndSyftJson Mime = "application/vnd.syft+json"

	// KMimeApplicationVndSyncmlDmNotification
	//
	// English:
	//
	//  Application type 'vnd.syncml.dm.notification'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.syncml.dm.notification'
	KMimeApplicationVndSyncmlDmNotification Mime = "application/vnd.syncml.dm.notification"

	// KMimeApplicationVndSyncmlDmddfXml
	//
	// English:
	//
	//  Application type 'vnd.syncml.dmddf+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.syncml.dmddf+xml'
	KMimeApplicationVndSyncmlDmddfXml Mime = "application/vnd.syncml.dmddf+xml"

	// KMimeApplicationVndSyncmlDmtndsWbxml
	//
	// English:
	//
	//  Application type 'vnd.syncml.dmtnds+wbxml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.syncml.dmtnds+wbxml'
	KMimeApplicationVndSyncmlDmtndsWbxml Mime = "application/vnd.syncml.dmtnds+wbxml"

	// KMimeApplicationVndSyncmlDmtndsXml
	//
	// English:
	//
	//  Application type 'vnd.syncml.dmtnds+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.syncml.dmtnds+xml'
	KMimeApplicationVndSyncmlDmtndsXml Mime = "application/vnd.syncml.dmtnds+xml"

	// KMimeApplicationVndSyncmlDmddfWbxml
	//
	// English:
	//
	//  Application type 'vnd.syncml.dmddf+wbxml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.syncml.dmddf+wbxml'
	KMimeApplicationVndSyncmlDmddfWbxml Mime = "application/vnd.syncml.dmddf+wbxml"

	// KMimeApplicationVndSyncmlDmWbxml
	//
	// English:
	//
	//  Application type 'vnd.syncml.dm+wbxml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.syncml.dm+wbxml'
	KMimeApplicationVndSyncmlDmWbxml Mime = "application/vnd.syncml.dm+wbxml"

	// KMimeApplicationVndSyncmlDmXml
	//
	// English:
	//
	//  Application type 'vnd.syncml.dm+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.syncml.dm+xml'
	KMimeApplicationVndSyncmlDmXml Mime = "application/vnd.syncml.dm+xml"

	// KMimeApplicationVndSyncmlDsNotification
	//
	// English:
	//
	//  Application type 'vnd.syncml.ds.notification'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.syncml.ds.notification'
	KMimeApplicationVndSyncmlDsNotification Mime = "application/vnd.syncml.ds.notification"

	// KMimeApplicationVndSyncmlXml
	//
	// English:
	//
	//  Application type 'vnd.syncml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.syncml+xml'
	KMimeApplicationVndSyncmlXml Mime = "application/vnd.syncml+xml"

	// KMimeApplicationVndTableschemaJson
	//
	// English:
	//
	//  Application type 'vnd.tableschema+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.tableschema+json'
	KMimeApplicationVndTableschemaJson Mime = "application/vnd.tableschema+json"

	// KMimeApplicationVndTaoIntentModuleArchive
	//
	// English:
	//
	//  Application type 'vnd.tao.intent-module-archive'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.tao.intent-module-archive'
	KMimeApplicationVndTaoIntentModuleArchive Mime = "application/vnd.tao.intent-module-archive"

	// KMimeApplicationVndTcpdumpPcap
	//
	// English:
	//
	//  Application type 'vnd.tcpdump.pcap'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.tcpdump.pcap'
	KMimeApplicationVndTcpdumpPcap Mime = "application/vnd.tcpdump.pcap"

	// KMimeApplicationVndThinkCellPpttcJson
	//
	// English:
	//
	//  Application type 'vnd.think-cell.ppttc+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.think-cell.ppttc+json'
	KMimeApplicationVndThinkCellPpttcJson Mime = "application/vnd.think-cell.ppttc+json"

	// KMimeApplicationVndTml
	//
	// English:
	//
	//  Application type 'vnd.tml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.tml'
	KMimeApplicationVndTml Mime = "application/vnd.tml"

	// KMimeApplicationVndTmdMediaflexApiXml
	//
	// English:
	//
	//  Application type 'vnd.tmd.mediaflex.api+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.tmd.mediaflex.api+xml'
	KMimeApplicationVndTmdMediaflexApiXml Mime = "application/vnd.tmd.mediaflex.api+xml"

	// KMimeApplicationVndTmobileLivetv
	//
	// English:
	//
	//  Application type 'vnd.tmobile-livetv'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.tmobile-livetv'
	KMimeApplicationVndTmobileLivetv Mime = "application/vnd.tmobile-livetv"

	// KMimeApplicationVndTriOnesource
	//
	// English:
	//
	//  Application type 'vnd.tri.onesource'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.tri.onesource'
	KMimeApplicationVndTriOnesource Mime = "application/vnd.tri.onesource"

	// KMimeApplicationVndTridTpt
	//
	// English:
	//
	//  Application type 'vnd.trid.tpt'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.trid.tpt'
	KMimeApplicationVndTridTpt Mime = "application/vnd.trid.tpt"

	// KMimeApplicationVndTriscapeMxs
	//
	// English:
	//
	//  Application type 'vnd.triscape.mxs'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.triscape.mxs'
	KMimeApplicationVndTriscapeMxs Mime = "application/vnd.triscape.mxs"

	// KMimeApplicationVndTrueapp
	//
	// English:
	//
	//  Application type 'vnd.trueapp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.trueapp'
	KMimeApplicationVndTrueapp Mime = "application/vnd.trueapp"

	// KMimeApplicationVndTruedoc
	//
	// English:
	//
	//  Application type 'vnd.truedoc'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.truedoc'
	KMimeApplicationVndTruedoc Mime = "application/vnd.truedoc"

	// KMimeApplicationVndUbisoftWebplayer
	//
	// English:
	//
	//  Application type 'vnd.ubisoft.webplayer'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ubisoft.webplayer'
	KMimeApplicationVndUbisoftWebplayer Mime = "application/vnd.ubisoft.webplayer"

	// KMimeApplicationVndUfdl
	//
	// English:
	//
	//  Application type 'vnd.ufdl'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ufdl'
	KMimeApplicationVndUfdl Mime = "application/vnd.ufdl"

	// KMimeApplicationVndUiqTheme
	//
	// English:
	//
	//  Application type 'vnd.uiq.theme'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.uiq.theme'
	KMimeApplicationVndUiqTheme Mime = "application/vnd.uiq.theme"

	// KMimeApplicationVndUmajin
	//
	// English:
	//
	//  Application type 'vnd.umajin'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.umajin'
	KMimeApplicationVndUmajin Mime = "application/vnd.umajin"

	// KMimeApplicationVndUnity
	//
	// English:
	//
	//  Application type 'vnd.unity'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.unity'
	KMimeApplicationVndUnity Mime = "application/vnd.unity"

	// KMimeApplicationVndUomlXml
	//
	// English:
	//
	//  Application type 'vnd.uoml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.uoml+xml'
	KMimeApplicationVndUomlXml Mime = "application/vnd.uoml+xml"

	// KMimeApplicationVndUplanetAlert
	//
	// English:
	//
	//  Application type 'vnd.uplanet.alert'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.uplanet.alert'
	KMimeApplicationVndUplanetAlert Mime = "application/vnd.uplanet.alert"

	// KMimeApplicationVndUplanetAlertWbxml
	//
	// English:
	//
	//  Application type 'vnd.uplanet.alert-wbxml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.uplanet.alert-wbxml'
	KMimeApplicationVndUplanetAlertWbxml Mime = "application/vnd.uplanet.alert-wbxml"

	// KMimeApplicationVndUplanetBearerChoice
	//
	// English:
	//
	//  Application type 'vnd.uplanet.bearer-choice'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.uplanet.bearer-choice'
	KMimeApplicationVndUplanetBearerChoice Mime = "application/vnd.uplanet.bearer-choice"

	// KMimeApplicationVndUplanetBearerChoiceWbxml
	//
	// English:
	//
	//  Application type 'vnd.uplanet.bearer-choice-wbxml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.uplanet.bearer-choice-wbxml'
	KMimeApplicationVndUplanetBearerChoiceWbxml Mime = "application/vnd.uplanet.bearer-choice-wbxml"

	// KMimeApplicationVndUplanetCacheop
	//
	// English:
	//
	//  Application type 'vnd.uplanet.cacheop'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.uplanet.cacheop'
	KMimeApplicationVndUplanetCacheop Mime = "application/vnd.uplanet.cacheop"

	// KMimeApplicationVndUplanetCacheopWbxml
	//
	// English:
	//
	//  Application type 'vnd.uplanet.cacheop-wbxml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.uplanet.cacheop-wbxml'
	KMimeApplicationVndUplanetCacheopWbxml Mime = "application/vnd.uplanet.cacheop-wbxml"

	// KMimeApplicationVndUplanetChannel
	//
	// English:
	//
	//  Application type 'vnd.uplanet.channel'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.uplanet.channel'
	KMimeApplicationVndUplanetChannel Mime = "application/vnd.uplanet.channel"

	// KMimeApplicationVndUplanetChannelWbxml
	//
	// English:
	//
	//  Application type 'vnd.uplanet.channel-wbxml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.uplanet.channel-wbxml'
	KMimeApplicationVndUplanetChannelWbxml Mime = "application/vnd.uplanet.channel-wbxml"

	// KMimeApplicationVndUplanetList
	//
	// English:
	//
	//  Application type 'vnd.uplanet.list'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.uplanet.list'
	KMimeApplicationVndUplanetList Mime = "application/vnd.uplanet.list"

	// KMimeApplicationVndUplanetListcmd
	//
	// English:
	//
	//  Application type 'vnd.uplanet.listcmd'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.uplanet.listcmd'
	KMimeApplicationVndUplanetListcmd Mime = "application/vnd.uplanet.listcmd"

	// KMimeApplicationVndUplanetListcmdWbxml
	//
	// English:
	//
	//  Application type 'vnd.uplanet.listcmd-wbxml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.uplanet.listcmd-wbxml'
	KMimeApplicationVndUplanetListcmdWbxml Mime = "application/vnd.uplanet.listcmd-wbxml"

	// KMimeApplicationVndUplanetListWbxml
	//
	// English:
	//
	//  Application type 'vnd.uplanet.list-wbxml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.uplanet.list-wbxml'
	KMimeApplicationVndUplanetListWbxml Mime = "application/vnd.uplanet.list-wbxml"

	// KMimeApplicationVndUriMap
	//
	// English:
	//
	//  Application type 'vnd.uri-map'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.uri-map'
	KMimeApplicationVndUriMap Mime = "application/vnd.uri-map"

	// KMimeApplicationVndUplanetSignal
	//
	// English:
	//
	//  Application type 'vnd.uplanet.signal'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.uplanet.signal'
	KMimeApplicationVndUplanetSignal Mime = "application/vnd.uplanet.signal"

	// KMimeApplicationVndValveSourceMaterial
	//
	// English:
	//
	//  Application type 'vnd.valve.source.material'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.valve.source.material'
	KMimeApplicationVndValveSourceMaterial Mime = "application/vnd.valve.source.material"

	// KMimeApplicationVndVcx
	//
	// English:
	//
	//  Application type 'vnd.vcx'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.vcx'
	KMimeApplicationVndVcx Mime = "application/vnd.vcx"

	// KMimeApplicationVndVdStudy
	//
	// English:
	//
	//  Application type 'vnd.vd-study'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.vd-study'
	KMimeApplicationVndVdStudy Mime = "application/vnd.vd-study"

	// KMimeApplicationVndVectorworks
	//
	// English:
	//
	//  Application type 'vnd.vectorworks'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.vectorworks'
	KMimeApplicationVndVectorworks Mime = "application/vnd.vectorworks"

	// KMimeApplicationVndVelJson
	//
	// English:
	//
	//  Application type 'vnd.vel+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.vel+json'
	KMimeApplicationVndVelJson Mime = "application/vnd.vel+json"

	// KMimeApplicationVndVerimatrixVcas
	//
	// English:
	//
	//  Application type 'vnd.verimatrix.vcas'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.verimatrix.vcas'
	KMimeApplicationVndVerimatrixVcas Mime = "application/vnd.verimatrix.vcas"

	// KMimeApplicationVndVeritoneAionJson
	//
	// English:
	//
	//  Application type 'vnd.veritone.aion+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.veritone.aion+json'
	KMimeApplicationVndVeritoneAionJson Mime = "application/vnd.veritone.aion+json"

	// KMimeApplicationVndVeryantThin
	//
	// English:
	//
	//  Application type 'vnd.veryant.thin'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.veryant.thin'
	KMimeApplicationVndVeryantThin Mime = "application/vnd.veryant.thin"

	// KMimeApplicationVndVesEncrypted
	//
	// English:
	//
	//  Application type 'vnd.ves.encrypted'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ves.encrypted'
	KMimeApplicationVndVesEncrypted Mime = "application/vnd.ves.encrypted"

	// KMimeApplicationVndVidsoftVidconference
	//
	// English:
	//
	//  Application type 'vnd.vidsoft.vidconference'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.vidsoft.vidconference'
	KMimeApplicationVndVidsoftVidconference Mime = "application/vnd.vidsoft.vidconference"

	// KMimeApplicationVndVisio
	//
	// English:
	//
	//  Application type 'vnd.visio'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.visio'
	KMimeApplicationVndVisio Mime = "application/vnd.visio"

	// KMimeApplicationVndVisionary
	//
	// English:
	//
	//  Application type 'vnd.visionary'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.visionary'
	KMimeApplicationVndVisionary Mime = "application/vnd.visionary"

	// KMimeApplicationVndVividenceScriptfile
	//
	// English:
	//
	//  Application type 'vnd.vividence.scriptfile'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.vividence.scriptfile'
	KMimeApplicationVndVividenceScriptfile Mime = "application/vnd.vividence.scriptfile"

	// KMimeApplicationVndVsf
	//
	// English:
	//
	//  Application type 'vnd.vsf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.vsf'
	KMimeApplicationVndVsf Mime = "application/vnd.vsf"

	// KMimeApplicationVndWapSic
	//
	// English:
	//
	//  Application type 'vnd.wap.sic'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wap.sic'
	KMimeApplicationVndWapSic Mime = "application/vnd.wap.sic"

	// KMimeApplicationVndWapSlc
	//
	// English:
	//
	//  Application type 'vnd.wap.slc'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wap.slc'
	KMimeApplicationVndWapSlc Mime = "application/vnd.wap.slc"

	// KMimeApplicationVndWapWbxml
	//
	// English:
	//
	//  Application type 'vnd.wap.wbxml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wap.wbxml'
	KMimeApplicationVndWapWbxml Mime = "application/vnd.wap.wbxml"

	// KMimeApplicationVndWapWmlc
	//
	// English:
	//
	//  Application type 'vnd.wap.wmlc'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wap.wmlc'
	KMimeApplicationVndWapWmlc Mime = "application/vnd.wap.wmlc"

	// KMimeApplicationVndWapWmlscriptc
	//
	// English:
	//
	//  Application type 'vnd.wap.wmlscriptc'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wap.wmlscriptc'
	KMimeApplicationVndWapWmlscriptc Mime = "application/vnd.wap.wmlscriptc"

	// KMimeApplicationVndWebturbo
	//
	// English:
	//
	//  Application type 'vnd.webturbo'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.webturbo'
	KMimeApplicationVndWebturbo Mime = "application/vnd.webturbo"

	// KMimeApplicationVndWfaDpp
	//
	// English:
	//
	//  Application type 'vnd.wfa.dpp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wfa.dpp'
	KMimeApplicationVndWfaDpp Mime = "application/vnd.wfa.dpp"

	// KMimeApplicationVndWfaP2p
	//
	// English:
	//
	//  Application type 'vnd.wfa.p2p'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wfa.p2p'
	KMimeApplicationVndWfaP2p Mime = "application/vnd.wfa.p2p"

	// KMimeApplicationVndWfaWsc
	//
	// English:
	//
	//  Application type 'vnd.wfa.wsc'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wfa.wsc'
	KMimeApplicationVndWfaWsc Mime = "application/vnd.wfa.wsc"

	// KMimeApplicationVndWindowsDevicepairing
	//
	// English:
	//
	//  Application type 'vnd.windows.devicepairing'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.windows.devicepairing'
	KMimeApplicationVndWindowsDevicepairing Mime = "application/vnd.windows.devicepairing"

	// KMimeApplicationVndWmc
	//
	// English:
	//
	//  Application type 'vnd.wmc'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wmc'
	KMimeApplicationVndWmc Mime = "application/vnd.wmc"

	// KMimeApplicationVndWmfBootstrap
	//
	// English:
	//
	//  Application type 'vnd.wmf.bootstrap'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wmf.bootstrap'
	KMimeApplicationVndWmfBootstrap Mime = "application/vnd.wmf.bootstrap"

	// KMimeApplicationVndWolframMathematica
	//
	// English:
	//
	//  Application type 'vnd.wolfram.mathematica'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wolfram.mathematica'
	KMimeApplicationVndWolframMathematica Mime = "application/vnd.wolfram.mathematica"

	// KMimeApplicationVndWolframMathematicaPackage
	//
	// English:
	//
	//  Application type 'vnd.wolfram.mathematica.package'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wolfram.mathematica.package'
	KMimeApplicationVndWolframMathematicaPackage Mime = "application/vnd.wolfram.mathematica.package"

	// KMimeApplicationVndWolframPlayer
	//
	// English:
	//
	//  Application type 'vnd.wolfram.player'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wolfram.player'
	KMimeApplicationVndWolframPlayer Mime = "application/vnd.wolfram.player"

	// KMimeApplicationVndWordperfect
	//
	// English:
	//
	//  Application type 'vnd.wordperfect'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wordperfect'
	KMimeApplicationVndWordperfect Mime = "application/vnd.wordperfect"

	// KMimeApplicationVndWqd
	//
	// English:
	//
	//  Application type 'vnd.wqd'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wqd'
	KMimeApplicationVndWqd Mime = "application/vnd.wqd"

	// KMimeApplicationVndWrqHp3000Labelled
	//
	// English:
	//
	//  Application type 'vnd.wrq-hp3000-labelled'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wrq-hp3000-labelled'
	KMimeApplicationVndWrqHp3000Labelled Mime = "application/vnd.wrq-hp3000-labelled"

	// KMimeApplicationVndWtStf
	//
	// English:
	//
	//  Application type 'vnd.wt.stf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wt.stf'
	KMimeApplicationVndWtStf Mime = "application/vnd.wt.stf"

	// KMimeApplicationVndWvCspXml
	//
	// English:
	//
	//  Application type 'vnd.wv.csp+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wv.csp+xml'
	KMimeApplicationVndWvCspXml Mime = "application/vnd.wv.csp+xml"

	// KMimeApplicationVndWvCspWbxml
	//
	// English:
	//
	//  Application type 'vnd.wv.csp+wbxml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wv.csp+wbxml'
	KMimeApplicationVndWvCspWbxml Mime = "application/vnd.wv.csp+wbxml"

	// KMimeApplicationVndWvSspXml
	//
	// English:
	//
	//  Application type 'vnd.wv.ssp+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wv.ssp+xml'
	KMimeApplicationVndWvSspXml Mime = "application/vnd.wv.ssp+xml"

	// KMimeApplicationVndXacmlJson
	//
	// English:
	//
	//  Application type 'vnd.xacml+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.xacml+json'
	KMimeApplicationVndXacmlJson Mime = "application/vnd.xacml+json"

	// KMimeApplicationVndXara
	//
	// English:
	//
	//  Application type 'vnd.xara'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.xara'
	KMimeApplicationVndXara Mime = "application/vnd.xara"

	// KMimeApplicationVndXfdl
	//
	// English:
	//
	//  Application type 'vnd.xfdl'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.xfdl'
	KMimeApplicationVndXfdl Mime = "application/vnd.xfdl"

	// KMimeApplicationVndXfdlWebform
	//
	// English:
	//
	//  Application type 'vnd.xfdl.webform'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.xfdl.webform'
	KMimeApplicationVndXfdlWebform Mime = "application/vnd.xfdl.webform"

	// KMimeApplicationVndXmiXml
	//
	// English:
	//
	//  Application type 'vnd.xmi+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.xmi+xml'
	KMimeApplicationVndXmiXml Mime = "application/vnd.xmi+xml"

	// KMimeApplicationVndXmpieCpkg
	//
	// English:
	//
	//  Application type 'vnd.xmpie.cpkg'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.xmpie.cpkg'
	KMimeApplicationVndXmpieCpkg Mime = "application/vnd.xmpie.cpkg"

	// KMimeApplicationVndXmpieDpkg
	//
	// English:
	//
	//  Application type 'vnd.xmpie.dpkg'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.xmpie.dpkg'
	KMimeApplicationVndXmpieDpkg Mime = "application/vnd.xmpie.dpkg"

	// KMimeApplicationVndXmpiePlan
	//
	// English:
	//
	//  Application type 'vnd.xmpie.plan'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.xmpie.plan'
	KMimeApplicationVndXmpiePlan Mime = "application/vnd.xmpie.plan"

	// KMimeApplicationVndXmpiePpkg
	//
	// English:
	//
	//  Application type 'vnd.xmpie.ppkg'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.xmpie.ppkg'
	KMimeApplicationVndXmpiePpkg Mime = "application/vnd.xmpie.ppkg"

	// KMimeApplicationVndXmpieXlim
	//
	// English:
	//
	//  Application type 'vnd.xmpie.xlim'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.xmpie.xlim'
	KMimeApplicationVndXmpieXlim Mime = "application/vnd.xmpie.xlim"

	// KMimeApplicationVndYamahaHvDic
	//
	// English:
	//
	//  Application type 'vnd.yamaha.hv-dic'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.yamaha.hv-dic'
	KMimeApplicationVndYamahaHvDic Mime = "application/vnd.yamaha.hv-dic"

	// KMimeApplicationVndYamahaHvScript
	//
	// English:
	//
	//  Application type 'vnd.yamaha.hv-script'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.yamaha.hv-script'
	KMimeApplicationVndYamahaHvScript Mime = "application/vnd.yamaha.hv-script"

	// KMimeApplicationVndYamahaHvVoice
	//
	// English:
	//
	//  Application type 'vnd.yamaha.hv-voice'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.yamaha.hv-voice'
	KMimeApplicationVndYamahaHvVoice Mime = "application/vnd.yamaha.hv-voice"

	// KMimeApplicationVndYamahaOpenscoreformatOsfpvgXml
	//
	// English:
	//
	//  Application type 'vnd.yamaha.openscoreformat.osfpvg+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.yamaha.openscoreformat.osfpvg+xml'
	KMimeApplicationVndYamahaOpenscoreformatOsfpvgXml Mime = "application/vnd.yamaha.openscoreformat.osfpvg+xml"

	// KMimeApplicationVndYamahaOpenscoreformat
	//
	// English:
	//
	//  Application type 'vnd.yamaha.openscoreformat'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.yamaha.openscoreformat'
	KMimeApplicationVndYamahaOpenscoreformat Mime = "application/vnd.yamaha.openscoreformat"

	// KMimeApplicationVndYamahaRemoteSetup
	//
	// English:
	//
	//  Application type 'vnd.yamaha.remote-setup'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.yamaha.remote-setup'
	KMimeApplicationVndYamahaRemoteSetup Mime = "application/vnd.yamaha.remote-setup"

	// KMimeApplicationVndYamahaSmafAudio
	//
	// English:
	//
	//  Application type 'vnd.yamaha.smaf-audio'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.yamaha.smaf-audio'
	KMimeApplicationVndYamahaSmafAudio Mime = "application/vnd.yamaha.smaf-audio"

	// KMimeApplicationVndYamahaSmafPhrase
	//
	// English:
	//
	//  Application type 'vnd.yamaha.smaf-phrase'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.yamaha.smaf-phrase'
	KMimeApplicationVndYamahaSmafPhrase Mime = "application/vnd.yamaha.smaf-phrase"

	// KMimeApplicationVndYamahaThroughNgn
	//
	// English:
	//
	//  Application type 'vnd.yamaha.through-ngn'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.yamaha.through-ngn'
	KMimeApplicationVndYamahaThroughNgn Mime = "application/vnd.yamaha.through-ngn"

	// KMimeApplicationVndYamahaTunnelUdpencap
	//
	// English:
	//
	//  Application type 'vnd.yamaha.tunnel-udpencap'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.yamaha.tunnel-udpencap'
	KMimeApplicationVndYamahaTunnelUdpencap Mime = "application/vnd.yamaha.tunnel-udpencap"

	// KMimeApplicationVndYaoweme
	//
	// English:
	//
	//  Application type 'vnd.yaoweme'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.yaoweme'
	KMimeApplicationVndYaoweme Mime = "application/vnd.yaoweme"

	// KMimeApplicationVndYellowriverCustomMenu
	//
	// English:
	//
	//  Application type 'vnd.yellowriver-custom-menu'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.yellowriver-custom-menu'
	KMimeApplicationVndYellowriverCustomMenu Mime = "application/vnd.yellowriver-custom-menu"

	// KMimeApplicationVndYoutubeYt
	//
	// English:
	//
	//  Application type 'vnd.youtube.yt'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.youtube.yt'
	KMimeApplicationVndYoutubeYt Mime = "(OBSOLETED"

	// KMimeApplicationVndZul
	//
	// English:
	//
	//  Application type 'vnd.zul'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.zul'
	KMimeApplicationVndZul Mime = "application/vnd.zul"

	// KMimeApplicationVndZzazzDeckXml
	//
	// English:
	//
	//  Application type 'vnd.zzazz.deck+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.zzazz.deck+xml'
	KMimeApplicationVndZzazzDeckXml Mime = "application/vnd.zzazz.deck+xml"

	// KMimeApplicationVoicexmlXml
	//
	// English:
	//
	//  Application type 'voicexml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'voicexml+xml'
	KMimeApplicationVoicexmlXml Mime = "application/voicexml+xml"

	// KMimeApplicationVoucherCmsJson
	//
	// English:
	//
	//  Application type 'voucher-cms+json'
	//
	// Português:
	//
	//  Aplicação tipo 'voucher-cms+json'
	KMimeApplicationVoucherCmsJson Mime = "application/voucher-cms+json"

	// KMimeApplicationVqRtcpxr
	//
	// English:
	//
	//  Application type 'vq-rtcpxr'
	//
	// Português:
	//
	//  Aplicação tipo 'vq-rtcpxr'
	KMimeApplicationVqRtcpxr Mime = "application/vq-rtcpxr"

	// KMimeApplicationWasm
	//
	// English:
	//
	//  Application type 'wasm'
	//
	// Português:
	//
	//  Aplicação tipo 'wasm'
	KMimeApplicationWasm Mime = "application/wasm"

	// KMimeApplicationWatcherinfoXml
	//
	// English:
	//
	//  Application type 'watcherinfo+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'watcherinfo+xml'
	KMimeApplicationWatcherinfoXml Mime = "application/watcherinfo+xml"

	// KMimeApplicationWebpushOptionsJson
	//
	// English:
	//
	//  Application type 'webpush-options+json'
	//
	// Português:
	//
	//  Aplicação tipo 'webpush-options+json'
	KMimeApplicationWebpushOptionsJson Mime = "application/webpush-options+json"

	// KMimeApplicationWhoisppQuery
	//
	// English:
	//
	//  Application type 'whoispp-query'
	//
	// Português:
	//
	//  Aplicação tipo 'whoispp-query'
	KMimeApplicationWhoisppQuery Mime = "application/whoispp-query"

	// KMimeApplicationWhoisppResponse
	//
	// English:
	//
	//  Application type 'whoispp-response'
	//
	// Português:
	//
	//  Aplicação tipo 'whoispp-response'
	KMimeApplicationWhoisppResponse Mime = "application/whoispp-response"

	// KMimeApplicationWidget
	//
	// English:
	//
	//  Application type 'widget'
	//
	// Português:
	//
	//  Aplicação tipo 'widget'
	KMimeApplicationWidget Mime = "application/widget"

	// KMimeApplicationWita
	//
	// English:
	//
	//  Application type 'wita'
	//
	// Português:
	//
	//  Aplicação tipo 'wita'
	KMimeApplicationWita Mime = "application/wita"

	// KMimeApplicationWordperfect51
	//
	// English:
	//
	//  Application type 'wordperfect5.1'
	//
	// Português:
	//
	//  Aplicação tipo 'wordperfect5.1'
	KMimeApplicationWordperfect51 Mime = "application/wordperfect5.1"

	// KMimeApplicationWsdlXml
	//
	// English:
	//
	//  Application type 'wsdl+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'wsdl+xml'
	KMimeApplicationWsdlXml Mime = "application/wsdl+xml"

	// KMimeApplicationWspolicyXml
	//
	// English:
	//
	//  Application type 'wspolicy+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'wspolicy+xml'
	KMimeApplicationWspolicyXml Mime = "application/wspolicy+xml"

	// KMimeApplicationXPkiMessage
	//
	// English:
	//
	//  Application type 'x-pki-message'
	//
	// Português:
	//
	//  Aplicação tipo 'x-pki-message'
	KMimeApplicationXPkiMessage Mime = "application/x-pki-message"

	// KMimeApplicationXWwwFormUrlencoded
	//
	// English:
	//
	//  Application type 'x-www-form-urlencoded'
	//
	// Português:
	//
	//  Aplicação tipo 'x-www-form-urlencoded'
	KMimeApplicationXWwwFormUrlencoded Mime = "application/x-www-form-urlencoded"

	// KMimeApplicationXX509CaCert
	//
	// English:
	//
	//  Application type 'x-x509-ca-cert'
	//
	// Português:
	//
	//  Aplicação tipo 'x-x509-ca-cert'
	KMimeApplicationXX509CaCert Mime = "application/x-x509-ca-cert"

	// KMimeApplicationXX509CaRaCert
	//
	// English:
	//
	//  Application type 'x-x509-ca-ra-cert'
	//
	// Português:
	//
	//  Aplicação tipo 'x-x509-ca-ra-cert'
	KMimeApplicationXX509CaRaCert Mime = "application/x-x509-ca-ra-cert"

	// KMimeApplicationXX509NextCaCert
	//
	// English:
	//
	//  Application type 'x-x509-next-ca-cert'
	//
	// Português:
	//
	//  Aplicação tipo 'x-x509-next-ca-cert'
	KMimeApplicationXX509NextCaCert Mime = "application/x-x509-next-ca-cert"

	// KMimeApplicationX400Bp
	//
	// English:
	//
	//  Application type 'x400-bp'
	//
	// Português:
	//
	//  Aplicação tipo 'x400-bp'
	KMimeApplicationX400Bp Mime = "application/x400-bp"

	// KMimeApplicationXacmlXml
	//
	// English:
	//
	//  Application type 'xacml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xacml+xml'
	KMimeApplicationXacmlXml Mime = "application/xacml+xml"

	// KMimeApplicationXcapAttXml
	//
	// English:
	//
	//  Application type 'xcap-att+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xcap-att+xml'
	KMimeApplicationXcapAttXml Mime = "application/xcap-att+xml"

	// KMimeApplicationXcapCapsXml
	//
	// English:
	//
	//  Application type 'xcap-caps+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xcap-caps+xml'
	KMimeApplicationXcapCapsXml Mime = "application/xcap-caps+xml"

	// KMimeApplicationXcapDiffXml
	//
	// English:
	//
	//  Application type 'xcap-diff+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xcap-diff+xml'
	KMimeApplicationXcapDiffXml Mime = "application/xcap-diff+xml"

	// KMimeApplicationXcapElXml
	//
	// English:
	//
	//  Application type 'xcap-el+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xcap-el+xml'
	KMimeApplicationXcapElXml Mime = "application/xcap-el+xml"

	// KMimeApplicationXcapErrorXml
	//
	// English:
	//
	//  Application type 'xcap-error+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xcap-error+xml'
	KMimeApplicationXcapErrorXml Mime = "application/xcap-error+xml"

	// KMimeApplicationXcapNsXml
	//
	// English:
	//
	//  Application type 'xcap-ns+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xcap-ns+xml'
	KMimeApplicationXcapNsXml Mime = "application/xcap-ns+xml"

	// KMimeApplicationXconConferenceInfoDiffXml
	//
	// English:
	//
	//  Application type 'xcon-conference-info-diff+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xcon-conference-info-diff+xml'
	KMimeApplicationXconConferenceInfoDiffXml Mime = "application/xcon-conference-info-diff+xml"

	// KMimeApplicationXconConferenceInfoXml
	//
	// English:
	//
	//  Application type 'xcon-conference-info+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xcon-conference-info+xml'
	KMimeApplicationXconConferenceInfoXml Mime = "application/xcon-conference-info+xml"

	// KMimeApplicationXencXml
	//
	// English:
	//
	//  Application type 'xenc+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xenc+xml'
	KMimeApplicationXencXml Mime = "application/xenc+xml"

	// KMimeApplicationXhtmlXml
	//
	// English:
	//
	//  Application type 'xhtml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xhtml+xml'
	KMimeApplicationXhtmlXml Mime = "application/xhtml+xml"

	// KMimeApplicationXliffXml
	//
	// English:
	//
	//  Application type 'xliff+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xliff+xml'
	KMimeApplicationXliffXml Mime = "application/xliff+xml"

	// KMimeApplicationXml
	//
	// English:
	//
	//  Application type 'xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xml'
	KMimeApplicationXml Mime = "application/xml"

	// KMimeApplicationXmlDtd
	//
	// English:
	//
	//  Application type 'xml-dtd'
	//
	// Português:
	//
	//  Aplicação tipo 'xml-dtd'
	KMimeApplicationXmlDtd Mime = "application/xml-dtd"

	// KMimeApplicationXmlExternalParsedEntity
	//
	// English:
	//
	//  Application type 'xml-external-parsed-entity'
	//
	// Português:
	//
	//  Aplicação tipo 'xml-external-parsed-entity'
	KMimeApplicationXmlExternalParsedEntity Mime = "application/xml-external-parsed-entity"

	// KMimeApplicationXmlPatchXml
	//
	// English:
	//
	//  Application type 'xml-patch+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xml-patch+xml'
	KMimeApplicationXmlPatchXml Mime = "application/xml-patch+xml"

	// KMimeApplicationXmppXml
	//
	// English:
	//
	//  Application type 'xmpp+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xmpp+xml'
	KMimeApplicationXmppXml Mime = "application/xmpp+xml"

	// KMimeApplicationXopXml
	//
	// English:
	//
	//  Application type 'xop+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xop+xml'
	KMimeApplicationXopXml Mime = "application/xop+xml"

	// KMimeApplicationXsltXml
	//
	// English:
	//
	//  Application type 'xslt+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xslt+xml'
	KMimeApplicationXsltXml Mime = "application/xslt+xml"

	// KMimeApplicationXvXml
	//
	// English:
	//
	//  Application type 'xv+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xv+xml'
	KMimeApplicationXvXml Mime = "application/xv+xml"

	// KMimeApplicationYang
	//
	// English:
	//
	//  Application type 'yang'
	//
	// Português:
	//
	//  Aplicação tipo 'yang'
	KMimeApplicationYang Mime = "application/yang"

	// KMimeApplicationYangDataCbor
	//
	// English:
	//
	//  Application type 'yang-data+cbor'
	//
	// Português:
	//
	//  Aplicação tipo 'yang-data+cbor'
	KMimeApplicationYangDataCbor Mime = "application/yang-data+cbor"

	// KMimeApplicationYangDataJson
	//
	// English:
	//
	//  Application type 'yang-data+json'
	//
	// Português:
	//
	//  Aplicação tipo 'yang-data+json'
	KMimeApplicationYangDataJson Mime = "application/yang-data+json"

	// KMimeApplicationYangDataXml
	//
	// English:
	//
	//  Application type 'yang-data+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'yang-data+xml'
	KMimeApplicationYangDataXml Mime = "application/yang-data+xml"

	// KMimeApplicationYangPatchJson
	//
	// English:
	//
	//  Application type 'yang-patch+json'
	//
	// Português:
	//
	//  Aplicação tipo 'yang-patch+json'
	KMimeApplicationYangPatchJson Mime = "application/yang-patch+json"

	// KMimeApplicationYangPatchXml
	//
	// English:
	//
	//  Application type 'yang-patch+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'yang-patch+xml'
	KMimeApplicationYangPatchXml Mime = "application/yang-patch+xml"

	// KMimeApplicationYinXml
	//
	// English:
	//
	//  Application type 'yin+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'yin+xml'
	KMimeApplicationYinXml Mime = "application/yin+xml"

	// KMimeApplicationZip
	//
	// English:
	//
	//  Application type 'zip'
	//
	// Português:
	//
	//  Aplicação tipo 'zip'
	KMimeApplicationZip Mime = "application/zip"

	// KMimeApplicationZlib
	//
	// English:
	//
	//  Application type 'zlib'
	//
	// Português:
	//
	//  Aplicação tipo 'zlib'
	KMimeApplicationZlib Mime = "application/zlib"

	// KMimeApplicationZstd
	//
	// English:
	//
	//  Application type 'zstd'
	//
	// Português:
	//
	//  Aplicação tipo 'zstd'
	KMimeApplicationZstd Mime = "application/zstd"
)
const (
	// KMimeAudio1dInterleavedParityfec
	//
	// English:
	//
	//  Audio type '1d-interleaved-parityfec'
	//
	// Português:
	//
	//  Audio tipo '1d-interleaved-parityfec'
	KMimeAudio1dInterleavedParityfec Mime = "audio/1d-interleaved-parityfec"

	// KMimeAudio32kadpcm
	//
	// English:
	//
	//  Audio type '32kadpcm'
	//
	// Português:
	//
	//  Audio tipo '32kadpcm'
	KMimeAudio32kadpcm Mime = "audio/32kadpcm"

	// KMimeAudio3gpp
	//
	// English:
	//
	//  Audio type '3gpp'
	//
	// Português:
	//
	//  Audio tipo '3gpp'
	KMimeAudio3gpp Mime = "audio/3gpp"

	// KMimeAudio3gpp2
	//
	// English:
	//
	//  Audio type '3gpp2'
	//
	// Português:
	//
	//  Audio tipo '3gpp2'
	KMimeAudio3gpp2 Mime = "audio/3gpp2"

	// KMimeAudioAac
	//
	// English:
	//
	//  Audio type 'aac'
	//
	// Português:
	//
	//  Audio tipo 'aac'
	KMimeAudioAac Mime = "audio/aac"

	// KMimeAudioAc3
	//
	// English:
	//
	//  Audio type 'ac3'
	//
	// Português:
	//
	//  Audio tipo 'ac3'
	KMimeAudioAc3 Mime = "audio/ac3"

	// KMimeAudioAMR
	//
	// English:
	//
	//  Audio type 'AMR'
	//
	// Português:
	//
	//  Audio tipo 'AMR'
	KMimeAudioAMR Mime = "audio/AMR"

	// KMimeAudioAMRWB
	//
	// English:
	//
	//  Audio type 'AMR-WB'
	//
	// Português:
	//
	//  Audio tipo 'AMR-WB'
	KMimeAudioAMRWB Mime = "audio/AMR-WB"

	// KMimeAudioAmrWb
	//
	// English:
	//
	//  Audio type 'amr-wb+'
	//
	// Português:
	//
	//  Audio tipo 'amr-wb+'
	KMimeAudioAmrWb Mime = "audio/amr-wb+"

	// KMimeAudioAptx
	//
	// English:
	//
	//  Audio type 'aptx'
	//
	// Português:
	//
	//  Audio tipo 'aptx'
	KMimeAudioAptx Mime = "audio/aptx"

	// KMimeAudioAsc
	//
	// English:
	//
	//  Audio type 'asc'
	//
	// Português:
	//
	//  Audio tipo 'asc'
	KMimeAudioAsc Mime = "audio/asc"

	// KMimeAudioATRACADVANCEDLOSSLESS
	//
	// English:
	//
	//  Audio type 'ATRAC-ADVANCED-LOSSLESS'
	//
	// Português:
	//
	//  Audio tipo 'ATRAC-ADVANCED-LOSSLESS'
	KMimeAudioATRACADVANCEDLOSSLESS Mime = "audio/ATRAC-ADVANCED-LOSSLESS"

	// KMimeAudioATRACX
	//
	// English:
	//
	//  Audio type 'ATRAC-X'
	//
	// Português:
	//
	//  Audio tipo 'ATRAC-X'
	KMimeAudioATRACX Mime = "audio/ATRAC-X"

	// KMimeAudioATRAC3
	//
	// English:
	//
	//  Audio type 'ATRAC3'
	//
	// Português:
	//
	//  Audio tipo 'ATRAC3'
	KMimeAudioATRAC3 Mime = "audio/ATRAC3"

	// KMimeAudioBasic
	//
	// English:
	//
	//  Audio type 'basic'
	//
	// Português:
	//
	//  Audio tipo 'basic'
	KMimeAudioBasic Mime = "audio/basic"

	// KMimeAudioBV16
	//
	// English:
	//
	//  Audio type 'BV16'
	//
	// Português:
	//
	//  Audio tipo 'BV16'
	KMimeAudioBV16 Mime = "audio/BV16"

	// KMimeAudioBV32
	//
	// English:
	//
	//  Audio type 'BV32'
	//
	// Português:
	//
	//  Audio tipo 'BV32'
	KMimeAudioBV32 Mime = "audio/BV32"

	// KMimeAudioClearmode
	//
	// English:
	//
	//  Audio type 'clearmode'
	//
	// Português:
	//
	//  Audio tipo 'clearmode'
	KMimeAudioClearmode Mime = "audio/clearmode"

	// KMimeAudioCN
	//
	// English:
	//
	//  Audio type 'CN'
	//
	// Português:
	//
	//  Audio tipo 'CN'
	KMimeAudioCN Mime = "audio/CN"

	// KMimeAudioDAT12
	//
	// English:
	//
	//  Audio type 'DAT12'
	//
	// Português:
	//
	//  Audio tipo 'DAT12'
	KMimeAudioDAT12 Mime = "audio/DAT12"

	// KMimeAudioDls
	//
	// English:
	//
	//  Audio type 'dls'
	//
	// Português:
	//
	//  Audio tipo 'dls'
	KMimeAudioDls Mime = "audio/dls"

	// KMimeAudioDsrEs201108
	//
	// English:
	//
	//  Audio type 'dsr-es201108'
	//
	// Português:
	//
	//  Audio tipo 'dsr-es201108'
	KMimeAudioDsrEs201108 Mime = "audio/dsr-es201108"

	// KMimeAudioDsrEs202050
	//
	// English:
	//
	//  Audio type 'dsr-es202050'
	//
	// Português:
	//
	//  Audio tipo 'dsr-es202050'
	KMimeAudioDsrEs202050 Mime = "audio/dsr-es202050"

	// KMimeAudioDsrEs202211
	//
	// English:
	//
	//  Audio type 'dsr-es202211'
	//
	// Português:
	//
	//  Audio tipo 'dsr-es202211'
	KMimeAudioDsrEs202211 Mime = "audio/dsr-es202211"

	// KMimeAudioDsrEs202212
	//
	// English:
	//
	//  Audio type 'dsr-es202212'
	//
	// Português:
	//
	//  Audio tipo 'dsr-es202212'
	KMimeAudioDsrEs202212 Mime = "audio/dsr-es202212"

	// KMimeAudioDV
	//
	// English:
	//
	//  Audio type 'DV'
	//
	// Português:
	//
	//  Audio tipo 'DV'
	KMimeAudioDV Mime = "audio/DV"

	// KMimeAudioDVI4
	//
	// English:
	//
	//  Audio type 'DVI4'
	//
	// Português:
	//
	//  Audio tipo 'DVI4'
	KMimeAudioDVI4 Mime = "audio/DVI4"

	// KMimeAudioEac3
	//
	// English:
	//
	//  Audio type 'eac3'
	//
	// Português:
	//
	//  Audio tipo 'eac3'
	KMimeAudioEac3 Mime = "audio/eac3"

	// KMimeAudioEncaprtp
	//
	// English:
	//
	//  Audio type 'encaprtp'
	//
	// Português:
	//
	//  Audio tipo 'encaprtp'
	KMimeAudioEncaprtp Mime = "audio/encaprtp"

	// KMimeAudioEVRC
	//
	// English:
	//
	//  Audio type 'EVRC'
	//
	// Português:
	//
	//  Audio tipo 'EVRC'
	KMimeAudioEVRC Mime = "audio/EVRC"

	// KMimeAudioEVRCQCP
	//
	// English:
	//
	//  Audio type 'EVRC-QCP'
	//
	// Português:
	//
	//  Audio tipo 'EVRC-QCP'
	KMimeAudioEVRCQCP Mime = "audio/EVRC-QCP"

	// KMimeAudioEVRC0
	//
	// English:
	//
	//  Audio type 'EVRC0'
	//
	// Português:
	//
	//  Audio tipo 'EVRC0'
	KMimeAudioEVRC0 Mime = "audio/EVRC0"

	// KMimeAudioEVRC1
	//
	// English:
	//
	//  Audio type 'EVRC1'
	//
	// Português:
	//
	//  Audio tipo 'EVRC1'
	KMimeAudioEVRC1 Mime = "audio/EVRC1"

	// KMimeAudioEVRCB
	//
	// English:
	//
	//  Audio type 'EVRCB'
	//
	// Português:
	//
	//  Audio tipo 'EVRCB'
	KMimeAudioEVRCB Mime = "audio/EVRCB"

	// KMimeAudioEVRCB0
	//
	// English:
	//
	//  Audio type 'EVRCB0'
	//
	// Português:
	//
	//  Audio tipo 'EVRCB0'
	KMimeAudioEVRCB0 Mime = "audio/EVRCB0"

	// KMimeAudioEVRCB1
	//
	// English:
	//
	//  Audio type 'EVRCB1'
	//
	// Português:
	//
	//  Audio tipo 'EVRCB1'
	KMimeAudioEVRCB1 Mime = "audio/EVRCB1"

	// KMimeAudioEVRCNW
	//
	// English:
	//
	//  Audio type 'EVRCNW'
	//
	// Português:
	//
	//  Audio tipo 'EVRCNW'
	KMimeAudioEVRCNW Mime = "audio/EVRCNW"

	// KMimeAudioEVRCNW0
	//
	// English:
	//
	//  Audio type 'EVRCNW0'
	//
	// Português:
	//
	//  Audio tipo 'EVRCNW0'
	KMimeAudioEVRCNW0 Mime = "audio/EVRCNW0"

	// KMimeAudioEVRCNW1
	//
	// English:
	//
	//  Audio type 'EVRCNW1'
	//
	// Português:
	//
	//  Audio tipo 'EVRCNW1'
	KMimeAudioEVRCNW1 Mime = "audio/EVRCNW1"

	// KMimeAudioEVRCWB
	//
	// English:
	//
	//  Audio type 'EVRCWB'
	//
	// Português:
	//
	//  Audio tipo 'EVRCWB'
	KMimeAudioEVRCWB Mime = "audio/EVRCWB"

	// KMimeAudioEVRCWB0
	//
	// English:
	//
	//  Audio type 'EVRCWB0'
	//
	// Português:
	//
	//  Audio tipo 'EVRCWB0'
	KMimeAudioEVRCWB0 Mime = "audio/EVRCWB0"

	// KMimeAudioEVRCWB1
	//
	// English:
	//
	//  Audio type 'EVRCWB1'
	//
	// Português:
	//
	//  Audio tipo 'EVRCWB1'
	KMimeAudioEVRCWB1 Mime = "audio/EVRCWB1"

	// KMimeAudioEVS
	//
	// English:
	//
	//  Audio type 'EVS'
	//
	// Português:
	//
	//  Audio tipo 'EVS'
	KMimeAudioEVS Mime = "audio/EVS"

	// KMimeAudioExample
	//
	// English:
	//
	//  Audio type 'example'
	//
	// Português:
	//
	//  Audio tipo 'example'
	KMimeAudioExample Mime = "audio/example"

	// KMimeAudioFlexfec
	//
	// English:
	//
	//  Audio type 'flexfec'
	//
	// Português:
	//
	//  Audio tipo 'flexfec'
	KMimeAudioFlexfec Mime = "audio/flexfec"

	// KMimeAudioFwdred
	//
	// English:
	//
	//  Audio type 'fwdred'
	//
	// Português:
	//
	//  Audio tipo 'fwdred'
	KMimeAudioFwdred Mime = "audio/fwdred"

	// KMimeAudioG7110
	//
	// English:
	//
	//  Audio type 'G711-0'
	//
	// Português:
	//
	//  Audio tipo 'G711-0'
	KMimeAudioG7110 Mime = "audio/G711-0"

	// KMimeAudioG719
	//
	// English:
	//
	//  Audio type 'G719'
	//
	// Português:
	//
	//  Audio tipo 'G719'
	KMimeAudioG719 Mime = "audio/G719"

	// KMimeAudioG7221
	//
	// English:
	//
	//  Audio type 'G7221'
	//
	// Português:
	//
	//  Audio tipo 'G7221'
	KMimeAudioG7221 Mime = "audio/G7221"

	// KMimeAudioG722
	//
	// English:
	//
	//  Audio type 'G722'
	//
	// Português:
	//
	//  Audio tipo 'G722'
	KMimeAudioG722 Mime = "audio/G722"

	// KMimeAudioG723
	//
	// English:
	//
	//  Audio type 'G723'
	//
	// Português:
	//
	//  Audio tipo 'G723'
	KMimeAudioG723 Mime = "audio/G723"

	// KMimeAudioG72616
	//
	// English:
	//
	//  Audio type 'G726-16'
	//
	// Português:
	//
	//  Audio tipo 'G726-16'
	KMimeAudioG72616 Mime = "audio/G726-16"

	// KMimeAudioG72624
	//
	// English:
	//
	//  Audio type 'G726-24'
	//
	// Português:
	//
	//  Audio tipo 'G726-24'
	KMimeAudioG72624 Mime = "audio/G726-24"

	// KMimeAudioG72632
	//
	// English:
	//
	//  Audio type 'G726-32'
	//
	// Português:
	//
	//  Audio tipo 'G726-32'
	KMimeAudioG72632 Mime = "audio/G726-32"

	// KMimeAudioG72640
	//
	// English:
	//
	//  Audio type 'G726-40'
	//
	// Português:
	//
	//  Audio tipo 'G726-40'
	KMimeAudioG72640 Mime = "audio/G726-40"

	// KMimeAudioG728
	//
	// English:
	//
	//  Audio type 'G728'
	//
	// Português:
	//
	//  Audio tipo 'G728'
	KMimeAudioG728 Mime = "audio/G728"

	// KMimeAudioG729
	//
	// English:
	//
	//  Audio type 'G729'
	//
	// Português:
	//
	//  Audio tipo 'G729'
	KMimeAudioG729 Mime = "audio/G729"

	// KMimeAudioG7291
	//
	// English:
	//
	//  Audio type 'G7291'
	//
	// Português:
	//
	//  Audio tipo 'G7291'
	KMimeAudioG7291 Mime = "audio/G7291"

	// KMimeAudioG729D
	//
	// English:
	//
	//  Audio type 'G729D'
	//
	// Português:
	//
	//  Audio tipo 'G729D'
	KMimeAudioG729D Mime = "audio/G729D"

	// KMimeAudioG729E
	//
	// English:
	//
	//  Audio type 'G729E'
	//
	// Português:
	//
	//  Audio tipo 'G729E'
	KMimeAudioG729E Mime = "audio/G729E"

	// KMimeAudioGSM
	//
	// English:
	//
	//  Audio type 'GSM'
	//
	// Português:
	//
	//  Audio tipo 'GSM'
	KMimeAudioGSM Mime = "audio/GSM"

	// KMimeAudioGSMEFR
	//
	// English:
	//
	//  Audio type 'GSM-EFR'
	//
	// Português:
	//
	//  Audio tipo 'GSM-EFR'
	KMimeAudioGSMEFR Mime = "audio/GSM-EFR"

	// KMimeAudioGSMHR08
	//
	// English:
	//
	//  Audio type 'GSM-HR-08'
	//
	// Português:
	//
	//  Audio tipo 'GSM-HR-08'
	KMimeAudioGSMHR08 Mime = "audio/GSM-HR-08"

	// KMimeAudioILBC
	//
	// English:
	//
	//  Audio type 'iLBC'
	//
	// Português:
	//
	//  Audio tipo 'iLBC'
	KMimeAudioILBC Mime = "audio/iLBC"

	// KMimeAudioIpMrV25
	//
	// English:
	//
	//  Audio type 'ip-mr_v2.5'
	//
	// Português:
	//
	//  Audio tipo 'ip-mr_v2.5'
	KMimeAudioIpMrV25 Mime = "audio/ip-mr_v2.5"

	// KMimeAudioL8
	//
	// English:
	//
	//  Audio type 'L8'
	//
	// Português:
	//
	//  Audio tipo 'L8'
	KMimeAudioL8 Mime = "audio/L8"

	// KMimeAudioL16
	//
	// English:
	//
	//  Audio type 'L16'
	//
	// Português:
	//
	//  Audio tipo 'L16'
	KMimeAudioL16 Mime = "audio/L16"

	// KMimeAudioL20
	//
	// English:
	//
	//  Audio type 'L20'
	//
	// Português:
	//
	//  Audio tipo 'L20'
	KMimeAudioL20 Mime = "audio/L20"

	// KMimeAudioL24
	//
	// English:
	//
	//  Audio type 'L24'
	//
	// Português:
	//
	//  Audio tipo 'L24'
	KMimeAudioL24 Mime = "audio/L24"

	// KMimeAudioLPC
	//
	// English:
	//
	//  Audio type 'LPC'
	//
	// Português:
	//
	//  Audio tipo 'LPC'
	KMimeAudioLPC Mime = "audio/LPC"

	// KMimeAudioMELP
	//
	// English:
	//
	//  Audio type 'MELP'
	//
	// Português:
	//
	//  Audio tipo 'MELP'
	KMimeAudioMELP Mime = "audio/MELP"

	// KMimeAudioMELP600
	//
	// English:
	//
	//  Audio type 'MELP600'
	//
	// Português:
	//
	//  Audio tipo 'MELP600'
	KMimeAudioMELP600 Mime = "audio/MELP600"

	// KMimeAudioMELP1200
	//
	// English:
	//
	//  Audio type 'MELP1200'
	//
	// Português:
	//
	//  Audio tipo 'MELP1200'
	KMimeAudioMELP1200 Mime = "audio/MELP1200"

	// KMimeAudioMELP2400
	//
	// English:
	//
	//  Audio type 'MELP2400'
	//
	// Português:
	//
	//  Audio tipo 'MELP2400'
	KMimeAudioMELP2400 Mime = "audio/MELP2400"

	// KMimeAudioMhas
	//
	// English:
	//
	//  Audio type 'mhas'
	//
	// Português:
	//
	//  Audio tipo 'mhas'
	KMimeAudioMhas Mime = "audio/mhas"

	// KMimeAudioMobileXmf
	//
	// English:
	//
	//  Audio type 'mobile-xmf'
	//
	// Português:
	//
	//  Audio tipo 'mobile-xmf'
	KMimeAudioMobileXmf Mime = "audio/mobile-xmf"

	// KMimeAudioMPA
	//
	// English:
	//
	//  Audio type 'MPA'
	//
	// Português:
	//
	//  Audio tipo 'MPA'
	KMimeAudioMPA Mime = "audio/MPA"

	// KMimeAudioMp4
	//
	// English:
	//
	//  Audio type 'mp4'
	//
	// Português:
	//
	//  Audio tipo 'mp4'
	KMimeAudioMp4 Mime = "audio/mp4"

	// KMimeAudioMP4ALATM
	//
	// English:
	//
	//  Audio type 'MP4A-LATM'
	//
	// Português:
	//
	//  Audio tipo 'MP4A-LATM'
	KMimeAudioMP4ALATM Mime = "audio/MP4A-LATM"

	// KMimeAudioMpaRobust
	//
	// English:
	//
	//  Audio type 'mpa-robust'
	//
	// Português:
	//
	//  Audio tipo 'mpa-robust'
	KMimeAudioMpaRobust Mime = "audio/mpa-robust"

	// KMimeAudioMpeg
	//
	// English:
	//
	//  Audio type 'mpeg'
	//
	// Português:
	//
	//  Audio tipo 'mpeg'
	KMimeAudioMpeg Mime = "audio/mpeg"

	// KMimeAudioMpeg4Generic
	//
	// English:
	//
	//  Audio type 'mpeg4-generic'
	//
	// Português:
	//
	//  Audio tipo 'mpeg4-generic'
	KMimeAudioMpeg4Generic Mime = "audio/mpeg4-generic"

	// KMimeAudioOgg
	//
	// English:
	//
	//  Audio type 'ogg'
	//
	// Português:
	//
	//  Audio tipo 'ogg'
	KMimeAudioOgg Mime = "audio/ogg"

	// KMimeAudioOpus
	//
	// English:
	//
	//  Audio type 'opus'
	//
	// Português:
	//
	//  Audio tipo 'opus'
	KMimeAudioOpus Mime = "audio/opus"

	// KMimeAudioParityfec
	//
	// English:
	//
	//  Audio type 'parityfec'
	//
	// Português:
	//
	//  Audio tipo 'parityfec'
	KMimeAudioParityfec Mime = "audio/parityfec"

	// KMimeAudioPCMA
	//
	// English:
	//
	//  Audio type 'PCMA'
	//
	// Português:
	//
	//  Audio tipo 'PCMA'
	KMimeAudioPCMA Mime = "audio/PCMA"

	// KMimeAudioPCMAWB
	//
	// English:
	//
	//  Audio type 'PCMA-WB'
	//
	// Português:
	//
	//  Audio tipo 'PCMA-WB'
	KMimeAudioPCMAWB Mime = "audio/PCMA-WB"

	// KMimeAudioPCMU
	//
	// English:
	//
	//  Audio type 'PCMU'
	//
	// Português:
	//
	//  Audio tipo 'PCMU'
	KMimeAudioPCMU Mime = "audio/PCMU"

	// KMimeAudioPCMUWB
	//
	// English:
	//
	//  Audio type 'PCMU-WB'
	//
	// Português:
	//
	//  Audio tipo 'PCMU-WB'
	KMimeAudioPCMUWB Mime = "audio/PCMU-WB"

	// KMimeAudioPrsSid
	//
	// English:
	//
	//  Audio type 'prs.sid'
	//
	// Português:
	//
	//  Audio tipo 'prs.sid'
	KMimeAudioPrsSid Mime = "audio/prs.sid"

	// KMimeAudioQCELP
	//
	// English:
	//
	//  Audio type 'QCELP'
	//
	// Português:
	//
	//  Audio tipo 'QCELP'
	KMimeAudioQCELP Mime = "audio/QCELP"

	// KMimeAudioRaptorfec
	//
	// English:
	//
	//  Audio type 'raptorfec'
	//
	// Português:
	//
	//  Audio tipo 'raptorfec'
	KMimeAudioRaptorfec Mime = "audio/raptorfec"

	// KMimeAudioRED
	//
	// English:
	//
	//  Audio type 'RED'
	//
	// Português:
	//
	//  Audio tipo 'RED'
	KMimeAudioRED Mime = "audio/RED"

	// KMimeAudioRtpEncAescm128
	//
	// English:
	//
	//  Audio type 'rtp-enc-aescm128'
	//
	// Português:
	//
	//  Audio tipo 'rtp-enc-aescm128'
	KMimeAudioRtpEncAescm128 Mime = "audio/rtp-enc-aescm128"

	// KMimeAudioRtploopback
	//
	// English:
	//
	//  Audio type 'rtploopback'
	//
	// Português:
	//
	//  Audio tipo 'rtploopback'
	KMimeAudioRtploopback Mime = "audio/rtploopback"

	// KMimeAudioRtpMidi
	//
	// English:
	//
	//  Audio type 'rtp-midi'
	//
	// Português:
	//
	//  Audio tipo 'rtp-midi'
	KMimeAudioRtpMidi Mime = "audio/rtp-midi"

	// KMimeAudioRtx
	//
	// English:
	//
	//  Audio type 'rtx'
	//
	// Português:
	//
	//  Audio tipo 'rtx'
	KMimeAudioRtx Mime = "audio/rtx"

	// KMimeAudioScip
	//
	// English:
	//
	//  Audio type 'scip'
	//
	// Português:
	//
	//  Audio tipo 'scip'
	KMimeAudioScip Mime = "audio/scip"

	// KMimeAudioSMV
	//
	// English:
	//
	//  Audio type 'SMV'
	//
	// Português:
	//
	//  Audio tipo 'SMV'
	KMimeAudioSMV Mime = "audio/SMV"

	// KMimeAudioSMV0
	//
	// English:
	//
	//  Audio type 'SMV0'
	//
	// Português:
	//
	//  Audio tipo 'SMV0'
	KMimeAudioSMV0 Mime = "audio/SMV0"

	// KMimeAudioSMVQCP
	//
	// English:
	//
	//  Audio type 'SMV-QCP'
	//
	// Português:
	//
	//  Audio tipo 'SMV-QCP'
	KMimeAudioSMVQCP Mime = "audio/SMV-QCP"

	// KMimeAudioSofa
	//
	// English:
	//
	//  Audio type 'sofa'
	//
	// Português:
	//
	//  Audio tipo 'sofa'
	KMimeAudioSofa Mime = "audio/sofa"

	// KMimeAudioSpMidi
	//
	// English:
	//
	//  Audio type 'sp-midi'
	//
	// Português:
	//
	//  Audio tipo 'sp-midi'
	KMimeAudioSpMidi Mime = "audio/sp-midi"

	// KMimeAudioSpeex
	//
	// English:
	//
	//  Audio type 'speex'
	//
	// Português:
	//
	//  Audio tipo 'speex'
	KMimeAudioSpeex Mime = "audio/speex"

	// KMimeAudioT140c
	//
	// English:
	//
	//  Audio type 't140c'
	//
	// Português:
	//
	//  Audio tipo 't140c'
	KMimeAudioT140c Mime = "audio/t140c"

	// KMimeAudioT38
	//
	// English:
	//
	//  Audio type 't38'
	//
	// Português:
	//
	//  Audio tipo 't38'
	KMimeAudioT38 Mime = "audio/t38"

	// KMimeAudioTelephoneEvent
	//
	// English:
	//
	//  Audio type 'telephone-event'
	//
	// Português:
	//
	//  Audio tipo 'telephone-event'
	KMimeAudioTelephoneEvent Mime = "audio/telephone-event"

	// KMimeAudioTETRAACELP
	//
	// English:
	//
	//  Audio type 'TETRA_ACELP'
	//
	// Português:
	//
	//  Audio tipo 'TETRA_ACELP'
	KMimeAudioTETRAACELP Mime = "audio/TETRA_ACELP"

	// KMimeAudioTETRAACELPBB
	//
	// English:
	//
	//  Audio type 'TETRA_ACELP_BB'
	//
	// Português:
	//
	//  Audio tipo 'TETRA_ACELP_BB'
	KMimeAudioTETRAACELPBB Mime = "audio/TETRA_ACELP_BB"

	// KMimeAudioTone
	//
	// English:
	//
	//  Audio type 'tone'
	//
	// Português:
	//
	//  Audio tipo 'tone'
	KMimeAudioTone Mime = "audio/tone"

	// KMimeAudioTSVCIS
	//
	// English:
	//
	//  Audio type 'TSVCIS'
	//
	// Português:
	//
	//  Audio tipo 'TSVCIS'
	KMimeAudioTSVCIS Mime = "audio/TSVCIS"

	// KMimeAudioUEMCLIP
	//
	// English:
	//
	//  Audio type 'UEMCLIP'
	//
	// Português:
	//
	//  Audio tipo 'UEMCLIP'
	KMimeAudioUEMCLIP Mime = "audio/UEMCLIP"

	// KMimeAudioUlpfec
	//
	// English:
	//
	//  Audio type 'ulpfec'
	//
	// Português:
	//
	//  Audio tipo 'ulpfec'
	KMimeAudioUlpfec Mime = "audio/ulpfec"

	// KMimeAudioUsac
	//
	// English:
	//
	//  Audio type 'usac'
	//
	// Português:
	//
	//  Audio tipo 'usac'
	KMimeAudioUsac Mime = "audio/usac"

	// KMimeAudioVDVI
	//
	// English:
	//
	//  Audio type 'VDVI'
	//
	// Português:
	//
	//  Audio tipo 'VDVI'
	KMimeAudioVDVI Mime = "audio/VDVI"

	// KMimeAudioVMRWB
	//
	// English:
	//
	//  Audio type 'VMR-WB'
	//
	// Português:
	//
	//  Audio tipo 'VMR-WB'
	KMimeAudioVMRWB Mime = "audio/VMR-WB"

	// KMimeAudioVnd3gppIufp
	//
	// English:
	//
	//  Audio type 'vnd.3gpp.iufp'
	//
	// Português:
	//
	//  Audio tipo 'vnd.3gpp.iufp'
	KMimeAudioVnd3gppIufp Mime = "audio/vnd.3gpp.iufp"

	// KMimeAudioVnd4SB
	//
	// English:
	//
	//  Audio type 'vnd.4SB'
	//
	// Português:
	//
	//  Audio tipo 'vnd.4SB'
	KMimeAudioVnd4SB Mime = "audio/vnd.4SB"

	// KMimeAudioVndAudiokoz
	//
	// English:
	//
	//  Audio type 'vnd.audiokoz'
	//
	// Português:
	//
	//  Audio tipo 'vnd.audiokoz'
	KMimeAudioVndAudiokoz Mime = "audio/vnd.audiokoz"

	// KMimeAudioVndCELP
	//
	// English:
	//
	//  Audio type 'vnd.CELP'
	//
	// Português:
	//
	//  Audio tipo 'vnd.CELP'
	KMimeAudioVndCELP Mime = "audio/vnd.CELP"

	// KMimeAudioVndCiscoNse
	//
	// English:
	//
	//  Audio type 'vnd.cisco.nse'
	//
	// Português:
	//
	//  Audio tipo 'vnd.cisco.nse'
	KMimeAudioVndCiscoNse Mime = "audio/vnd.cisco.nse"

	// KMimeAudioVndCmlesRadioEvents
	//
	// English:
	//
	//  Audio type 'vnd.cmles.radio-events'
	//
	// Português:
	//
	//  Audio tipo 'vnd.cmles.radio-events'
	KMimeAudioVndCmlesRadioEvents Mime = "audio/vnd.cmles.radio-events"

	// KMimeAudioVndCnsAnp1
	//
	// English:
	//
	//  Audio type 'vnd.cns.anp1'
	//
	// Português:
	//
	//  Audio tipo 'vnd.cns.anp1'
	KMimeAudioVndCnsAnp1 Mime = "audio/vnd.cns.anp1"

	// KMimeAudioVndCnsInf1
	//
	// English:
	//
	//  Audio type 'vnd.cns.inf1'
	//
	// Português:
	//
	//  Audio tipo 'vnd.cns.inf1'
	KMimeAudioVndCnsInf1 Mime = "audio/vnd.cns.inf1"

	// KMimeAudioVndDeceAudio
	//
	// English:
	//
	//  Audio type 'vnd.dece.audio'
	//
	// Português:
	//
	//  Audio tipo 'vnd.dece.audio'
	KMimeAudioVndDeceAudio Mime = "audio/vnd.dece.audio"

	// KMimeAudioVndDigitalWinds
	//
	// English:
	//
	//  Audio type 'vnd.digital-winds'
	//
	// Português:
	//
	//  Audio tipo 'vnd.digital-winds'
	KMimeAudioVndDigitalWinds Mime = "audio/vnd.digital-winds"

	// KMimeAudioVndDlnaAdts
	//
	// English:
	//
	//  Audio type 'vnd.dlna.adts'
	//
	// Português:
	//
	//  Audio tipo 'vnd.dlna.adts'
	KMimeAudioVndDlnaAdts Mime = "audio/vnd.dlna.adts"

	// KMimeAudioVndDolbyHeaac1
	//
	// English:
	//
	//  Audio type 'vnd.dolby.heaac.1'
	//
	// Português:
	//
	//  Audio tipo 'vnd.dolby.heaac.1'
	KMimeAudioVndDolbyHeaac1 Mime = "audio/vnd.dolby.heaac.1"

	// KMimeAudioVndDolbyHeaac2
	//
	// English:
	//
	//  Audio type 'vnd.dolby.heaac.2'
	//
	// Português:
	//
	//  Audio tipo 'vnd.dolby.heaac.2'
	KMimeAudioVndDolbyHeaac2 Mime = "audio/vnd.dolby.heaac.2"

	// KMimeAudioVndDolbyMlp
	//
	// English:
	//
	//  Audio type 'vnd.dolby.mlp'
	//
	// Português:
	//
	//  Audio tipo 'vnd.dolby.mlp'
	KMimeAudioVndDolbyMlp Mime = "audio/vnd.dolby.mlp"

	// KMimeAudioVndDolbyMps
	//
	// English:
	//
	//  Audio type 'vnd.dolby.mps'
	//
	// Português:
	//
	//  Audio tipo 'vnd.dolby.mps'
	KMimeAudioVndDolbyMps Mime = "audio/vnd.dolby.mps"

	// KMimeAudioVndDolbyPl2
	//
	// English:
	//
	//  Audio type 'vnd.dolby.pl2'
	//
	// Português:
	//
	//  Audio tipo 'vnd.dolby.pl2'
	KMimeAudioVndDolbyPl2 Mime = "audio/vnd.dolby.pl2"

	// KMimeAudioVndDolbyPl2x
	//
	// English:
	//
	//  Audio type 'vnd.dolby.pl2x'
	//
	// Português:
	//
	//  Audio tipo 'vnd.dolby.pl2x'
	KMimeAudioVndDolbyPl2x Mime = "audio/vnd.dolby.pl2x"

	// KMimeAudioVndDolbyPl2z
	//
	// English:
	//
	//  Audio type 'vnd.dolby.pl2z'
	//
	// Português:
	//
	//  Audio tipo 'vnd.dolby.pl2z'
	KMimeAudioVndDolbyPl2z Mime = "audio/vnd.dolby.pl2z"

	// KMimeAudioVndDolbyPulse1
	//
	// English:
	//
	//  Audio type 'vnd.dolby.pulse.1'
	//
	// Português:
	//
	//  Audio tipo 'vnd.dolby.pulse.1'
	KMimeAudioVndDolbyPulse1 Mime = "audio/vnd.dolby.pulse.1"

	// KMimeAudioVndDra
	//
	// English:
	//
	//  Audio type 'vnd.dra'
	//
	// Português:
	//
	//  Audio tipo 'vnd.dra'
	KMimeAudioVndDra Mime = "audio/vnd.dra"

	// KMimeAudioVndDts
	//
	// English:
	//
	//  Audio type 'vnd.dts'
	//
	// Português:
	//
	//  Audio tipo 'vnd.dts'
	KMimeAudioVndDts Mime = "audio/vnd.dts"

	// KMimeAudioVndDtsHd
	//
	// English:
	//
	//  Audio type 'vnd.dts.hd'
	//
	// Português:
	//
	//  Audio tipo 'vnd.dts.hd'
	KMimeAudioVndDtsHd Mime = "audio/vnd.dts.hd"

	// KMimeAudioVndDtsUhd
	//
	// English:
	//
	//  Audio type 'vnd.dts.uhd'
	//
	// Português:
	//
	//  Audio tipo 'vnd.dts.uhd'
	KMimeAudioVndDtsUhd Mime = "audio/vnd.dts.uhd"

	// KMimeAudioVndDvbFile
	//
	// English:
	//
	//  Audio type 'vnd.dvb.file'
	//
	// Português:
	//
	//  Audio tipo 'vnd.dvb.file'
	KMimeAudioVndDvbFile Mime = "audio/vnd.dvb.file"

	// KMimeAudioVndEveradPlj
	//
	// English:
	//
	//  Audio type 'vnd.everad.plj'
	//
	// Português:
	//
	//  Audio tipo 'vnd.everad.plj'
	KMimeAudioVndEveradPlj Mime = "audio/vnd.everad.plj"

	// KMimeAudioVndHnsAudio
	//
	// English:
	//
	//  Audio type 'vnd.hns.audio'
	//
	// Português:
	//
	//  Audio tipo 'vnd.hns.audio'
	KMimeAudioVndHnsAudio Mime = "audio/vnd.hns.audio"

	// KMimeAudioVndLucentVoice
	//
	// English:
	//
	//  Audio type 'vnd.lucent.voice'
	//
	// Português:
	//
	//  Audio tipo 'vnd.lucent.voice'
	KMimeAudioVndLucentVoice Mime = "audio/vnd.lucent.voice"

	// KMimeAudioVndMsPlayreadyMediaPya
	//
	// English:
	//
	//  Audio type 'vnd.ms-playready.media.pya'
	//
	// Português:
	//
	//  Audio tipo 'vnd.ms-playready.media.pya'
	KMimeAudioVndMsPlayreadyMediaPya Mime = "audio/vnd.ms-playready.media.pya"

	// KMimeAudioVndNokiaMobileXmf
	//
	// English:
	//
	//  Audio type 'vnd.nokia.mobile-xmf'
	//
	// Português:
	//
	//  Audio tipo 'vnd.nokia.mobile-xmf'
	KMimeAudioVndNokiaMobileXmf Mime = "audio/vnd.nokia.mobile-xmf"

	// KMimeAudioVndNortelVbk
	//
	// English:
	//
	//  Audio type 'vnd.nortel.vbk'
	//
	// Português:
	//
	//  Audio tipo 'vnd.nortel.vbk'
	KMimeAudioVndNortelVbk Mime = "audio/vnd.nortel.vbk"

	// KMimeAudioVndNueraEcelp4800
	//
	// English:
	//
	//  Audio type 'vnd.nuera.ecelp4800'
	//
	// Português:
	//
	//  Audio tipo 'vnd.nuera.ecelp4800'
	KMimeAudioVndNueraEcelp4800 Mime = "audio/vnd.nuera.ecelp4800"

	// KMimeAudioVndNueraEcelp7470
	//
	// English:
	//
	//  Audio type 'vnd.nuera.ecelp7470'
	//
	// Português:
	//
	//  Audio tipo 'vnd.nuera.ecelp7470'
	KMimeAudioVndNueraEcelp7470 Mime = "audio/vnd.nuera.ecelp7470"

	// KMimeAudioVndNueraEcelp9600
	//
	// English:
	//
	//  Audio type 'vnd.nuera.ecelp9600'
	//
	// Português:
	//
	//  Audio tipo 'vnd.nuera.ecelp9600'
	KMimeAudioVndNueraEcelp9600 Mime = "audio/vnd.nuera.ecelp9600"

	// KMimeAudioVndOctelSbc
	//
	// English:
	//
	//  Audio type 'vnd.octel.sbc'
	//
	// Português:
	//
	//  Audio tipo 'vnd.octel.sbc'
	KMimeAudioVndOctelSbc Mime = "audio/vnd.octel.sbc"

	// KMimeAudioVndPresonusMultitrack
	//
	// English:
	//
	//  Audio type 'vnd.presonus.multitrack'
	//
	// Português:
	//
	//  Audio tipo 'vnd.presonus.multitrack'
	KMimeAudioVndPresonusMultitrack Mime = "audio/vnd.presonus.multitrack"

	// KMimeAudioVndRhetorex32kadpcm
	//
	// English:
	//
	//  Audio type 'vnd.rhetorex.32kadpcm'
	//
	// Português:
	//
	//  Audio tipo 'vnd.rhetorex.32kadpcm'
	KMimeAudioVndRhetorex32kadpcm Mime = "audio/vnd.rhetorex.32kadpcm"

	// KMimeAudioVndRip
	//
	// English:
	//
	//  Audio type 'vnd.rip'
	//
	// Português:
	//
	//  Audio tipo 'vnd.rip'
	KMimeAudioVndRip Mime = "audio/vnd.rip"

	// KMimeAudioVndSealedmediaSoftsealMpeg
	//
	// English:
	//
	//  Audio type 'vnd.sealedmedia.softseal.mpeg'
	//
	// Português:
	//
	//  Audio tipo 'vnd.sealedmedia.softseal.mpeg'
	KMimeAudioVndSealedmediaSoftsealMpeg Mime = "audio/vnd.sealedmedia.softseal.mpeg"

	// KMimeAudioVndVmxCvsd
	//
	// English:
	//
	//  Audio type 'vnd.vmx.cvsd'
	//
	// Português:
	//
	//  Audio tipo 'vnd.vmx.cvsd'
	KMimeAudioVndVmxCvsd Mime = "audio/vnd.vmx.cvsd"

	// KMimeAudioVorbis
	//
	// English:
	//
	//  Audio type 'vorbis'
	//
	// Português:
	//
	//  Audio tipo 'vorbis'
	KMimeAudioVorbis Mime = "audio/vorbis"

	// KMimeAudioVorbisConfig
	//
	// English:
	//
	//  Audio type 'vorbis-config'
	//
	// Português:
	//
	//  Audio tipo 'vorbis-config'
	KMimeAudioVorbisConfig Mime = "audio/vorbis-config"
)
const (
	// KMimeFontCollection
	//
	// English:
	//
	//  Font type 'collection'
	//
	// Português:
	//
	//  Fonte tipo 'collection'
	KMimeFontCollection Mime = "font/collection"

	// KMimeFontOtf
	//
	// English:
	//
	//  Font type 'otf'
	//
	// Português:
	//
	//  Fonte tipo 'otf'
	KMimeFontOtf Mime = "font/otf"

	// KMimeFontSfnt
	//
	// English:
	//
	//  Font type 'sfnt'
	//
	// Português:
	//
	//  Fonte tipo 'sfnt'
	KMimeFontSfnt Mime = "font/sfnt"

	// KMimeFontTtf
	//
	// English:
	//
	//  Font type 'ttf'
	//
	// Português:
	//
	//  Fonte tipo 'ttf'
	KMimeFontTtf Mime = "font/ttf"

	// KMimeFontWoff
	//
	// English:
	//
	//  Font type 'woff'
	//
	// Português:
	//
	//  Fonte tipo 'woff'
	KMimeFontWoff Mime = "font/woff"

	// KMimeFontWoff2
	//
	// English:
	//
	//  Font type 'woff2'
	//
	// Português:
	//
	//  Fonte tipo 'woff2'
	KMimeFontWoff2 Mime = "font/woff2"
)
const (
	// KMimeImageAces
	//
	// English:
	//
	//  Imagem type 'aces'
	//
	// Português:
	//
	//  Imagem tipo 'aces'
	KMimeImageAces Mime = "image/aces"

	// KMimeImageAvci
	//
	// English:
	//
	//  Imagem type 'avci'
	//
	// Português:
	//
	//  Imagem tipo 'avci'
	KMimeImageAvci Mime = "image/avci"

	// KMimeImageAvcs
	//
	// English:
	//
	//  Imagem type 'avcs'
	//
	// Português:
	//
	//  Imagem tipo 'avcs'
	KMimeImageAvcs Mime = "image/avcs"

	// KMimeImageAvif
	//
	// English:
	//
	//  Imagem type 'avif'
	//
	// Português:
	//
	//  Imagem tipo 'avif'
	KMimeImageAvif Mime = "image/avif"

	// KMimeImageBmp
	//
	// English:
	//
	//  Imagem type 'bmp'
	//
	// Português:
	//
	//  Imagem tipo 'bmp'
	KMimeImageBmp Mime = "image/bmp"

	// KMimeImageCgm
	//
	// English:
	//
	//  Imagem type 'cgm'
	//
	// Português:
	//
	//  Imagem tipo 'cgm'
	KMimeImageCgm Mime = "image/cgm"

	// KMimeImageDicomRle
	//
	// English:
	//
	//  Imagem type 'dicom-rle'
	//
	// Português:
	//
	//  Imagem tipo 'dicom-rle'
	KMimeImageDicomRle Mime = "image/dicom-rle"

	// KMimeImageEmf
	//
	// English:
	//
	//  Imagem type 'emf'
	//
	// Português:
	//
	//  Imagem tipo 'emf'
	KMimeImageEmf Mime = "image/emf"

	// KMimeImageExample
	//
	// English:
	//
	//  Imagem type 'example'
	//
	// Português:
	//
	//  Imagem tipo 'example'
	KMimeImageExample Mime = "image/example"

	// KMimeImageFits
	//
	// English:
	//
	//  Imagem type 'fits'
	//
	// Português:
	//
	//  Imagem tipo 'fits'
	KMimeImageFits Mime = "image/fits"

	// KMimeImageG3fax
	//
	// English:
	//
	//  Imagem type 'g3fax'
	//
	// Português:
	//
	//  Imagem tipo 'g3fax'
	KMimeImageG3fax Mime = "image/g3fax"

	// KMimeImageGif
	//
	// English:
	//
	//  Imagem type 'gif'
	//
	// Português:
	//
	//  Imagem tipo 'gif'
	KMimeImageGif Mime = "[RFC2045][RFC2046]"

	// KMimeImageHeic
	//
	// English:
	//
	//  Imagem type 'heic'
	//
	// Português:
	//
	//  Imagem tipo 'heic'
	KMimeImageHeic Mime = "image/heic"

	// KMimeImageHeicSequence
	//
	// English:
	//
	//  Imagem type 'heic-sequence'
	//
	// Português:
	//
	//  Imagem tipo 'heic-sequence'
	KMimeImageHeicSequence Mime = "image/heic-sequence"

	// KMimeImageHeif
	//
	// English:
	//
	//  Imagem type 'heif'
	//
	// Português:
	//
	//  Imagem tipo 'heif'
	KMimeImageHeif Mime = "image/heif"

	// KMimeImageHeifSequence
	//
	// English:
	//
	//  Imagem type 'heif-sequence'
	//
	// Português:
	//
	//  Imagem tipo 'heif-sequence'
	KMimeImageHeifSequence Mime = "image/heif-sequence"

	// KMimeImageHej2k
	//
	// English:
	//
	//  Imagem type 'hej2k'
	//
	// Português:
	//
	//  Imagem tipo 'hej2k'
	KMimeImageHej2k Mime = "image/hej2k"

	// KMimeImageHsj2
	//
	// English:
	//
	//  Imagem type 'hsj2'
	//
	// Português:
	//
	//  Imagem tipo 'hsj2'
	KMimeImageHsj2 Mime = "image/hsj2"

	// KMimeImageIef
	//
	// English:
	//
	//  Imagem type 'ief'
	//
	// Português:
	//
	//  Imagem tipo 'ief'
	KMimeImageIef Mime = "[RFC1314]"

	// KMimeImageJls
	//
	// English:
	//
	//  Imagem type 'jls'
	//
	// Português:
	//
	//  Imagem tipo 'jls'
	KMimeImageJls Mime = "image/jls"

	// KMimeImageJp2
	//
	// English:
	//
	//  Imagem type 'jp2'
	//
	// Português:
	//
	//  Imagem tipo 'jp2'
	KMimeImageJp2 Mime = "image/jp2"

	// KMimeImageJpeg
	//
	// English:
	//
	//  Imagem type 'jpeg'
	//
	// Português:
	//
	//  Imagem tipo 'jpeg'
	KMimeImageJpeg Mime = "[RFC2045][RFC2046]"

	// KMimeImageJph
	//
	// English:
	//
	//  Imagem type 'jph'
	//
	// Português:
	//
	//  Imagem tipo 'jph'
	KMimeImageJph Mime = "image/jph"

	// KMimeImageJphc
	//
	// English:
	//
	//  Imagem type 'jphc'
	//
	// Português:
	//
	//  Imagem tipo 'jphc'
	KMimeImageJphc Mime = "image/jphc"

	// KMimeImageJpm
	//
	// English:
	//
	//  Imagem type 'jpm'
	//
	// Português:
	//
	//  Imagem tipo 'jpm'
	KMimeImageJpm Mime = "image/jpm"

	// KMimeImageJpx
	//
	// English:
	//
	//  Imagem type 'jpx'
	//
	// Português:
	//
	//  Imagem tipo 'jpx'
	KMimeImageJpx Mime = "image/jpx"

	// KMimeImageJxr
	//
	// English:
	//
	//  Imagem type 'jxr'
	//
	// Português:
	//
	//  Imagem tipo 'jxr'
	KMimeImageJxr Mime = "image/jxr"

	// KMimeImageJxrA
	//
	// English:
	//
	//  Imagem type 'jxrA'
	//
	// Português:
	//
	//  Imagem tipo 'jxrA'
	KMimeImageJxrA Mime = "image/jxrA"

	// KMimeImageJxrS
	//
	// English:
	//
	//  Imagem type 'jxrS'
	//
	// Português:
	//
	//  Imagem tipo 'jxrS'
	KMimeImageJxrS Mime = "image/jxrS"

	// KMimeImageJxs
	//
	// English:
	//
	//  Imagem type 'jxs'
	//
	// Português:
	//
	//  Imagem tipo 'jxs'
	KMimeImageJxs Mime = "image/jxs"

	// KMimeImageJxsc
	//
	// English:
	//
	//  Imagem type 'jxsc'
	//
	// Português:
	//
	//  Imagem tipo 'jxsc'
	KMimeImageJxsc Mime = "image/jxsc"

	// KMimeImageJxsi
	//
	// English:
	//
	//  Imagem type 'jxsi'
	//
	// Português:
	//
	//  Imagem tipo 'jxsi'
	KMimeImageJxsi Mime = "image/jxsi"

	// KMimeImageJxss
	//
	// English:
	//
	//  Imagem type 'jxss'
	//
	// Português:
	//
	//  Imagem tipo 'jxss'
	KMimeImageJxss Mime = "image/jxss"

	// KMimeImageKtx
	//
	// English:
	//
	//  Imagem type 'ktx'
	//
	// Português:
	//
	//  Imagem tipo 'ktx'
	KMimeImageKtx Mime = "image/ktx"

	// KMimeImageKtx2
	//
	// English:
	//
	//  Imagem type 'ktx2'
	//
	// Português:
	//
	//  Imagem tipo 'ktx2'
	KMimeImageKtx2 Mime = "image/ktx2"

	// KMimeImageNaplps
	//
	// English:
	//
	//  Imagem type 'naplps'
	//
	// Português:
	//
	//  Imagem tipo 'naplps'
	KMimeImageNaplps Mime = "image/naplps"

	// KMimeImagePng
	//
	// English:
	//
	//  Imagem type 'png'
	//
	// Português:
	//
	//  Imagem tipo 'png'
	KMimeImagePng Mime = "image/png"

	// KMimeImagePrsBtif
	//
	// English:
	//
	//  Imagem type 'prs.btif'
	//
	// Português:
	//
	//  Imagem tipo 'prs.btif'
	KMimeImagePrsBtif Mime = "image/prs.btif"

	// KMimeImagePrsPti
	//
	// English:
	//
	//  Imagem type 'prs.pti'
	//
	// Português:
	//
	//  Imagem tipo 'prs.pti'
	KMimeImagePrsPti Mime = "image/prs.pti"

	// KMimeImagePwgRaster
	//
	// English:
	//
	//  Imagem type 'pwg-raster'
	//
	// Português:
	//
	//  Imagem tipo 'pwg-raster'
	KMimeImagePwgRaster Mime = "image/pwg-raster"

	// KMimeImageSvgXml
	//
	// English:
	//
	//  Imagem type 'svg+xml'
	//
	// Português:
	//
	//  Imagem tipo 'svg+xml'
	KMimeImageSvgXml Mime = "image/svg+xml"

	// KMimeImageT38
	//
	// English:
	//
	//  Imagem type 't38'
	//
	// Português:
	//
	//  Imagem tipo 't38'
	KMimeImageT38 Mime = "image/t38"

	// KMimeImageTiff
	//
	// English:
	//
	//  Imagem type 'tiff'
	//
	// Português:
	//
	//  Imagem tipo 'tiff'
	KMimeImageTiff Mime = "image/tiff"

	// KMimeImageTiffFx
	//
	// English:
	//
	//  Imagem type 'tiff-fx'
	//
	// Português:
	//
	//  Imagem tipo 'tiff-fx'
	KMimeImageTiffFx Mime = "image/tiff-fx"

	// KMimeImageVndAdobePhotoshop
	//
	// English:
	//
	//  Imagem type 'vnd.adobe.photoshop'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.adobe.photoshop'
	KMimeImageVndAdobePhotoshop Mime = "image/vnd.adobe.photoshop"

	// KMimeImageVndAirzipAcceleratorAzv
	//
	// English:
	//
	//  Imagem type 'vnd.airzip.accelerator.azv'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.airzip.accelerator.azv'
	KMimeImageVndAirzipAcceleratorAzv Mime = "image/vnd.airzip.accelerator.azv"

	// KMimeImageVndCnsInf2
	//
	// English:
	//
	//  Imagem type 'vnd.cns.inf2'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.cns.inf2'
	KMimeImageVndCnsInf2 Mime = "image/vnd.cns.inf2"

	// KMimeImageVndDeceGraphic
	//
	// English:
	//
	//  Imagem type 'vnd.dece.graphic'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.dece.graphic'
	KMimeImageVndDeceGraphic Mime = "image/vnd.dece.graphic"

	// KMimeImageVndDjvu
	//
	// English:
	//
	//  Imagem type 'vnd.djvu'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.djvu'
	KMimeImageVndDjvu Mime = "image/vnd.djvu"

	// KMimeImageVndDwg
	//
	// English:
	//
	//  Imagem type 'vnd.dwg'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.dwg'
	KMimeImageVndDwg Mime = "image/vnd.dwg"

	// KMimeImageVndDxf
	//
	// English:
	//
	//  Imagem type 'vnd.dxf'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.dxf'
	KMimeImageVndDxf Mime = "image/vnd.dxf"

	// KMimeImageVndDvbSubtitle
	//
	// English:
	//
	//  Imagem type 'vnd.dvb.subtitle'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.dvb.subtitle'
	KMimeImageVndDvbSubtitle Mime = "image/vnd.dvb.subtitle"

	// KMimeImageVndFastbidsheet
	//
	// English:
	//
	//  Imagem type 'vnd.fastbidsheet'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.fastbidsheet'
	KMimeImageVndFastbidsheet Mime = "image/vnd.fastbidsheet"

	// KMimeImageVndFpx
	//
	// English:
	//
	//  Imagem type 'vnd.fpx'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.fpx'
	KMimeImageVndFpx Mime = "image/vnd.fpx"

	// KMimeImageVndFst
	//
	// English:
	//
	//  Imagem type 'vnd.fst'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.fst'
	KMimeImageVndFst Mime = "image/vnd.fst"

	// KMimeImageVndFujixeroxEdmicsMmr
	//
	// English:
	//
	//  Imagem type 'vnd.fujixerox.edmics-mmr'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.fujixerox.edmics-mmr'
	KMimeImageVndFujixeroxEdmicsMmr Mime = "image/vnd.fujixerox.edmics-mmr"

	// KMimeImageVndFujixeroxEdmicsRlc
	//
	// English:
	//
	//  Imagem type 'vnd.fujixerox.edmics-rlc'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.fujixerox.edmics-rlc'
	KMimeImageVndFujixeroxEdmicsRlc Mime = "image/vnd.fujixerox.edmics-rlc"

	// KMimeImageVndGlobalgraphicsPgb
	//
	// English:
	//
	//  Imagem type 'vnd.globalgraphics.pgb'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.globalgraphics.pgb'
	KMimeImageVndGlobalgraphicsPgb Mime = "image/vnd.globalgraphics.pgb"

	// KMimeImageVndMicrosoftIcon
	//
	// English:
	//
	//  Imagem type 'vnd.microsoft.icon'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.microsoft.icon'
	KMimeImageVndMicrosoftIcon Mime = "image/vnd.microsoft.icon"

	// KMimeImageVndMix
	//
	// English:
	//
	//  Imagem type 'vnd.mix'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.mix'
	KMimeImageVndMix Mime = "image/vnd.mix"

	// KMimeImageVndMsModi
	//
	// English:
	//
	//  Imagem type 'vnd.ms-modi'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.ms-modi'
	KMimeImageVndMsModi Mime = "image/vnd.ms-modi"

	// KMimeImageVndMozillaApng
	//
	// English:
	//
	//  Imagem type 'vnd.mozilla.apng'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.mozilla.apng'
	KMimeImageVndMozillaApng Mime = "image/vnd.mozilla.apng"

	// KMimeImageVndNetFpx
	//
	// English:
	//
	//  Imagem type 'vnd.net-fpx'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.net-fpx'
	KMimeImageVndNetFpx Mime = "image/vnd.net-fpx"

	// KMimeImageVndPcoB16
	//
	// English:
	//
	//  Imagem type 'vnd.pco.b16'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.pco.b16'
	KMimeImageVndPcoB16 Mime = "image/vnd.pco.b16"

	// KMimeImageVndRadiance
	//
	// English:
	//
	//  Imagem type 'vnd.radiance'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.radiance'
	KMimeImageVndRadiance Mime = "image/vnd.radiance"

	// KMimeImageVndSealedPng
	//
	// English:
	//
	//  Imagem type 'vnd.sealed.png'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.sealed.png'
	KMimeImageVndSealedPng Mime = "image/vnd.sealed.png"

	// KMimeImageVndSealedmediaSoftsealGif
	//
	// English:
	//
	//  Imagem type 'vnd.sealedmedia.softseal.gif'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.sealedmedia.softseal.gif'
	KMimeImageVndSealedmediaSoftsealGif Mime = "image/vnd.sealedmedia.softseal.gif"

	// KMimeImageVndSealedmediaSoftsealJpg
	//
	// English:
	//
	//  Imagem type 'vnd.sealedmedia.softseal.jpg'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.sealedmedia.softseal.jpg'
	KMimeImageVndSealedmediaSoftsealJpg Mime = "image/vnd.sealedmedia.softseal.jpg"

	// KMimeImageVndSvf
	//
	// English:
	//
	//  Imagem type 'vnd.svf'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.svf'
	KMimeImageVndSvf Mime = "image/vnd.svf"

	// KMimeImageVndTencentTap
	//
	// English:
	//
	//  Imagem type 'vnd.tencent.tap'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.tencent.tap'
	KMimeImageVndTencentTap Mime = "image/vnd.tencent.tap"

	// KMimeImageVndValveSourceTexture
	//
	// English:
	//
	//  Imagem type 'vnd.valve.source.texture'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.valve.source.texture'
	KMimeImageVndValveSourceTexture Mime = "image/vnd.valve.source.texture"

	// KMimeImageVndWapWbmp
	//
	// English:
	//
	//  Imagem type 'vnd.wap.wbmp'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.wap.wbmp'
	KMimeImageVndWapWbmp Mime = "image/vnd.wap.wbmp"

	// KMimeImageVndXiff
	//
	// English:
	//
	//  Imagem type 'vnd.xiff'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.xiff'
	KMimeImageVndXiff Mime = "image/vnd.xiff"

	// KMimeImageVndZbrushPcx
	//
	// English:
	//
	//  Imagem type 'vnd.zbrush.pcx'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.zbrush.pcx'
	KMimeImageVndZbrushPcx Mime = "image/vnd.zbrush.pcx"

	// KMimeImageWmf
	//
	// English:
	//
	//  Imagem type 'wmf'
	//
	// Português:
	//
	//  Imagem tipo 'wmf'
	KMimeImageWmf Mime = "image/wmf"
)
const (
	// KMimeMessageCPIM
	//
	// English:
	//
	//  Message type 'CPIM'
	//
	// Português:
	//
	//  Mensagem tipo 'CPIM'
	KMimeMessageCPIM Mime = "message/CPIM"

	// KMimeMessageDeliveryStatus
	//
	// English:
	//
	//  Message type 'delivery-status'
	//
	// Português:
	//
	//  Mensagem tipo 'delivery-status'
	KMimeMessageDeliveryStatus Mime = "message/delivery-status"

	// KMimeMessageDispositionNotification
	//
	// English:
	//
	//  Message type 'disposition-notification'
	//
	// Português:
	//
	//  Mensagem tipo 'disposition-notification'
	KMimeMessageDispositionNotification Mime = "message/disposition-notification"

	// KMimeMessageExample
	//
	// English:
	//
	//  Message type 'example'
	//
	// Português:
	//
	//  Mensagem tipo 'example'
	KMimeMessageExample Mime = "message/example"

	// KMimeMessageExternalBody
	//
	// English:
	//
	//  Message type 'external-body'
	//
	// Português:
	//
	//  Mensagem tipo 'external-body'
	KMimeMessageExternalBody Mime = "[RFC2045][RFC2046]"

	// KMimeMessageFeedbackReport
	//
	// English:
	//
	//  Message type 'feedback-report'
	//
	// Português:
	//
	//  Mensagem tipo 'feedback-report'
	KMimeMessageFeedbackReport Mime = "message/feedback-report"

	// KMimeMessageGlobal
	//
	// English:
	//
	//  Message type 'global'
	//
	// Português:
	//
	//  Mensagem tipo 'global'
	KMimeMessageGlobal Mime = "message/global"

	// KMimeMessageGlobalDeliveryStatus
	//
	// English:
	//
	//  Message type 'global-delivery-status'
	//
	// Português:
	//
	//  Mensagem tipo 'global-delivery-status'
	KMimeMessageGlobalDeliveryStatus Mime = "message/global-delivery-status"

	// KMimeMessageGlobalDispositionNotification
	//
	// English:
	//
	//  Message type 'global-disposition-notification'
	//
	// Português:
	//
	//  Mensagem tipo 'global-disposition-notification'
	KMimeMessageGlobalDispositionNotification Mime = "message/global-disposition-notification"

	// KMimeMessageGlobalHeaders
	//
	// English:
	//
	//  Message type 'global-headers'
	//
	// Português:
	//
	//  Mensagem tipo 'global-headers'
	KMimeMessageGlobalHeaders Mime = "message/global-headers"

	// KMimeMessageHttp
	//
	// English:
	//
	//  Message type 'http'
	//
	// Português:
	//
	//  Mensagem tipo 'http'
	KMimeMessageHttp Mime = "message/http"

	// KMimeMessageImdnXml
	//
	// English:
	//
	//  Message type 'imdn+xml'
	//
	// Português:
	//
	//  Mensagem tipo 'imdn+xml'
	KMimeMessageImdnXml Mime = "message/imdn+xml"

	// KMimeMessagePartial
	//
	// English:
	//
	//  Message type 'partial'
	//
	// Português:
	//
	//  Mensagem tipo 'partial'
	KMimeMessagePartial Mime = "[RFC2045][RFC2046]"

	// KMimeMessageRfc822
	//
	// English:
	//
	//  Message type 'rfc822'
	//
	// Português:
	//
	//  Mensagem tipo 'rfc822'
	KMimeMessageRfc822 Mime = "[RFC2045][RFC2046]"

	// KMimeMessageSip
	//
	// English:
	//
	//  Message type 'sip'
	//
	// Português:
	//
	//  Mensagem tipo 'sip'
	KMimeMessageSip Mime = "message/sip"

	// KMimeMessageSipfrag
	//
	// English:
	//
	//  Message type 'sipfrag'
	//
	// Português:
	//
	//  Mensagem tipo 'sipfrag'
	KMimeMessageSipfrag Mime = "message/sipfrag"

	// KMimeMessageTrackingStatus
	//
	// English:
	//
	//  Message type 'tracking-status'
	//
	// Português:
	//
	//  Mensagem tipo 'tracking-status'
	KMimeMessageTrackingStatus Mime = "message/tracking-status"

	// KMimeMessageVndWfaWsc
	//
	// English:
	//
	//  Message type 'vnd.wfa.wsc'
	//
	// Português:
	//
	//  Mensagem tipo 'vnd.wfa.wsc'
	KMimeMessageVndWfaWsc Mime = "message/vnd.wfa.wsc"
)
const (
	// KMimeModel3mf
	//
	// English:
	//
	//  Model type '3mf'
	//
	// Português:
	//
	//  Modelo tipo '3mf'
	KMimeModel3mf Mime = "model/3mf"

	// KMimeModelE57
	//
	// English:
	//
	//  Model type 'e57'
	//
	// Português:
	//
	//  Modelo tipo 'e57'
	KMimeModelE57 Mime = "model/e57"

	// KMimeModelExample
	//
	// English:
	//
	//  Model type 'example'
	//
	// Português:
	//
	//  Modelo tipo 'example'
	KMimeModelExample Mime = "model/example"

	// KMimeModelGltfBinary
	//
	// English:
	//
	//  Model type 'gltf-binary'
	//
	// Português:
	//
	//  Modelo tipo 'gltf-binary'
	KMimeModelGltfBinary Mime = "model/gltf-binary"

	// KMimeModelGltfJson
	//
	// English:
	//
	//  Model type 'gltf+json'
	//
	// Português:
	//
	//  Modelo tipo 'gltf+json'
	KMimeModelGltfJson Mime = "model/gltf+json"

	// KMimeModelIges
	//
	// English:
	//
	//  Model type 'iges'
	//
	// Português:
	//
	//  Modelo tipo 'iges'
	KMimeModelIges Mime = "model/iges"

	// KMimeModelMesh
	//
	// English:
	//
	//  Model type 'mesh'
	//
	// Português:
	//
	//  Modelo tipo 'mesh'
	KMimeModelMesh Mime = "model/mesh"

	// KMimeModelMtl
	//
	// English:
	//
	//  Model type 'mtl'
	//
	// Português:
	//
	//  Modelo tipo 'mtl'
	KMimeModelMtl Mime = "model/mtl"

	// KMimeModelObj
	//
	// English:
	//
	//  Model type 'obj'
	//
	// Português:
	//
	//  Modelo tipo 'obj'
	KMimeModelObj Mime = "model/obj"

	// KMimeModelPrc
	//
	// English:
	//
	//  Model type 'prc'
	//
	// Português:
	//
	//  Modelo tipo 'prc'
	KMimeModelPrc Mime = "model/prc"

	// KMimeModelStep
	//
	// English:
	//
	//  Model type 'step'
	//
	// Português:
	//
	//  Modelo tipo 'step'
	KMimeModelStep Mime = "model/step"

	// KMimeModelStepXml
	//
	// English:
	//
	//  Model type 'step+xml'
	//
	// Português:
	//
	//  Modelo tipo 'step+xml'
	KMimeModelStepXml Mime = "model/step+xml"

	// KMimeModelStepZip
	//
	// English:
	//
	//  Model type 'step+zip'
	//
	// Português:
	//
	//  Modelo tipo 'step+zip'
	KMimeModelStepZip Mime = "model/step+zip"

	// KMimeModelStepXmlZip
	//
	// English:
	//
	//  Model type 'step-xml+zip'
	//
	// Português:
	//
	//  Modelo tipo 'step-xml+zip'
	KMimeModelStepXmlZip Mime = "model/step-xml+zip"

	// KMimeModelStl
	//
	// English:
	//
	//  Model type 'stl'
	//
	// Português:
	//
	//  Modelo tipo 'stl'
	KMimeModelStl Mime = "model/stl"

	// KMimeModelU3d
	//
	// English:
	//
	//  Model type 'u3d'
	//
	// Português:
	//
	//  Modelo tipo 'u3d'
	KMimeModelU3d Mime = "model/u3d"

	// KMimeModelVndColladaXml
	//
	// English:
	//
	//  Model type 'vnd.collada+xml'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.collada+xml'
	KMimeModelVndColladaXml Mime = "model/vnd.collada+xml"

	// KMimeModelVndDwf
	//
	// English:
	//
	//  Model type 'vnd.dwf'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.dwf'
	KMimeModelVndDwf Mime = "model/vnd.dwf"

	// KMimeModelVndFlatland3dml
	//
	// English:
	//
	//  Model type 'vnd.flatland.3dml'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.flatland.3dml'
	KMimeModelVndFlatland3dml Mime = "model/vnd.flatland.3dml"

	// KMimeModelVndGdl
	//
	// English:
	//
	//  Model type 'vnd.gdl'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.gdl'
	KMimeModelVndGdl Mime = "model/vnd.gdl"

	// KMimeModelVndGsGdl
	//
	// English:
	//
	//  Model type 'vnd.gs-gdl'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.gs-gdl'
	KMimeModelVndGsGdl Mime = "model/vnd.gs-gdl"

	// KMimeModelVndGtw
	//
	// English:
	//
	//  Model type 'vnd.gtw'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.gtw'
	KMimeModelVndGtw Mime = "model/vnd.gtw"

	// KMimeModelVndMomlXml
	//
	// English:
	//
	//  Model type 'vnd.moml+xml'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.moml+xml'
	KMimeModelVndMomlXml Mime = "model/vnd.moml+xml"

	// KMimeModelVndMts
	//
	// English:
	//
	//  Model type 'vnd.mts'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.mts'
	KMimeModelVndMts Mime = "model/vnd.mts"

	// KMimeModelVndOpengex
	//
	// English:
	//
	//  Model type 'vnd.opengex'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.opengex'
	KMimeModelVndOpengex Mime = "model/vnd.opengex"

	// KMimeModelVndParasolidTransmitBinary
	//
	// English:
	//
	//  Model type 'vnd.parasolid.transmit.binary'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.parasolid.transmit.binary'
	KMimeModelVndParasolidTransmitBinary Mime = "model/vnd.parasolid.transmit.binary"

	// KMimeModelVndParasolidTransmitText
	//
	// English:
	//
	//  Model type 'vnd.parasolid.transmit.text'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.parasolid.transmit.text'
	KMimeModelVndParasolidTransmitText Mime = "model/vnd.parasolid.transmit.text"

	// KMimeModelVndPythaPyox
	//
	// English:
	//
	//  Model type 'vnd.pytha.pyox'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.pytha.pyox'
	KMimeModelVndPythaPyox Mime = "model/vnd.pytha.pyox"

	// KMimeModelVndRosetteAnnotatedDataModel
	//
	// English:
	//
	//  Model type 'vnd.rosette.annotated-data-model'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.rosette.annotated-data-model'
	KMimeModelVndRosetteAnnotatedDataModel Mime = "model/vnd.rosette.annotated-data-model"

	// KMimeModelVndSapVds
	//
	// English:
	//
	//  Model type 'vnd.sap.vds'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.sap.vds'
	KMimeModelVndSapVds Mime = "model/vnd.sap.vds"

	// KMimeModelVndUsdzZip
	//
	// English:
	//
	//  Model type 'vnd.usdz+zip'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.usdz+zip'
	KMimeModelVndUsdzZip Mime = "model/vnd.usdz+zip"

	// KMimeModelVndValveSourceCompiledMap
	//
	// English:
	//
	//  Model type 'vnd.valve.source.compiled-map'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.valve.source.compiled-map'
	KMimeModelVndValveSourceCompiledMap Mime = "model/vnd.valve.source.compiled-map"

	// KMimeModelVndVtu
	//
	// English:
	//
	//  Model type 'vnd.vtu'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.vtu'
	KMimeModelVndVtu Mime = "model/vnd.vtu"

	// KMimeModelVrml
	//
	// English:
	//
	//  Model type 'vrml'
	//
	// Português:
	//
	//  Modelo tipo 'vrml'
	KMimeModelVrml Mime = "[RFC2077]"

	// KMimeModelX3dVrml
	//
	// English:
	//
	//  Model type 'x3d-vrml'
	//
	// Português:
	//
	//  Modelo tipo 'x3d-vrml'
	KMimeModelX3dVrml Mime = "model/x3d-vrml"

	// KMimeModelX3dFastinfoset
	//
	// English:
	//
	//  Model type 'x3d+fastinfoset'
	//
	// Português:
	//
	//  Modelo tipo 'x3d+fastinfoset'
	KMimeModelX3dFastinfoset Mime = "model/x3d+fastinfoset"

	// KMimeModelX3dXml
	//
	// English:
	//
	//  Model type 'x3d+xml'
	//
	// Português:
	//
	//  Modelo tipo 'x3d+xml'
	KMimeModelX3dXml Mime = "model/x3d+xml"
)
const (
	// KMimeMultipartAlternative
	//
	// English:
	//
	//  Multipart type 'alternative'
	//
	// Português:
	//
	//  Multiparte tipo 'alternative'
	KMimeMultipartAlternative Mime = "[RFC2046][RFC2045]"

	// KMimeMultipartAppledouble
	//
	// English:
	//
	//  Multipart type 'appledouble'
	//
	// Português:
	//
	//  Multiparte tipo 'appledouble'
	KMimeMultipartAppledouble Mime = "multipart/appledouble"

	// KMimeMultipartByteranges
	//
	// English:
	//
	//  Multipart type 'byteranges'
	//
	// Português:
	//
	//  Multiparte tipo 'byteranges'
	KMimeMultipartByteranges Mime = "multipart/byteranges"

	// KMimeMultipartDigest
	//
	// English:
	//
	//  Multipart type 'digest'
	//
	// Português:
	//
	//  Multiparte tipo 'digest'
	KMimeMultipartDigest Mime = "[RFC2046][RFC2045]"

	// KMimeMultipartEncrypted
	//
	// English:
	//
	//  Multipart type 'encrypted'
	//
	// Português:
	//
	//  Multiparte tipo 'encrypted'
	KMimeMultipartEncrypted Mime = "multipart/encrypted"

	// KMimeMultipartExample
	//
	// English:
	//
	//  Multipart type 'example'
	//
	// Português:
	//
	//  Multiparte tipo 'example'
	KMimeMultipartExample Mime = "multipart/example"

	// KMimeMultipartFormData
	//
	// English:
	//
	//  Multipart type 'form-data'
	//
	// Português:
	//
	//  Multiparte tipo 'form-data'
	KMimeMultipartFormData Mime = "multipart/form-data"

	// KMimeMultipartHeaderSet
	//
	// English:
	//
	//  Multipart type 'header-set'
	//
	// Português:
	//
	//  Multiparte tipo 'header-set'
	KMimeMultipartHeaderSet Mime = "multipart/header-set"

	// KMimeMultipartMixed
	//
	// English:
	//
	//  Multipart type 'mixed'
	//
	// Português:
	//
	//  Multiparte tipo 'mixed'
	KMimeMultipartMixed Mime = "[RFC2046][RFC2045]"

	// KMimeMultipartMultilingual
	//
	// English:
	//
	//  Multipart type 'multilingual'
	//
	// Português:
	//
	//  Multiparte tipo 'multilingual'
	KMimeMultipartMultilingual Mime = "multipart/multilingual"

	// KMimeMultipartParallel
	//
	// English:
	//
	//  Multipart type 'parallel'
	//
	// Português:
	//
	//  Multiparte tipo 'parallel'
	KMimeMultipartParallel Mime = "[RFC2046][RFC2045]"

	// KMimeMultipartRelated
	//
	// English:
	//
	//  Multipart type 'related'
	//
	// Português:
	//
	//  Multiparte tipo 'related'
	KMimeMultipartRelated Mime = "multipart/related"

	// KMimeMultipartReport
	//
	// English:
	//
	//  Multipart type 'report'
	//
	// Português:
	//
	//  Multiparte tipo 'report'
	KMimeMultipartReport Mime = "multipart/report"

	// KMimeMultipartSigned
	//
	// English:
	//
	//  Multipart type 'signed'
	//
	// Português:
	//
	//  Multiparte tipo 'signed'
	KMimeMultipartSigned Mime = "multipart/signed"

	// KMimeMultipartVndBintMedPlus
	//
	// English:
	//
	//  Multipart type 'vnd.bint.med-plus'
	//
	// Português:
	//
	//  Multiparte tipo 'vnd.bint.med-plus'
	KMimeMultipartVndBintMedPlus Mime = "multipart/vnd.bint.med-plus"

	// KMimeMultipartVoiceMessage
	//
	// English:
	//
	//  Multipart type 'voice-message'
	//
	// Português:
	//
	//  Multiparte tipo 'voice-message'
	KMimeMultipartVoiceMessage Mime = "multipart/voice-message"

	// KMimeMultipartXMixedReplace
	//
	// English:
	//
	//  Multipart type 'x-mixed-replace'
	//
	// Português:
	//
	//  Multiparte tipo 'x-mixed-replace'
	KMimeMultipartXMixedReplace Mime = "multipart/x-mixed-replace"
)
const (
	// KMimeText1dInterleavedParityfec
	//
	// English:
	//
	//  Text type '1d-interleaved-parityfec'
	//
	// Português:
	//
	//  Texto tipo '1d-interleaved-parityfec'
	KMimeText1dInterleavedParityfec Mime = "text/1d-interleaved-parityfec"

	// KMimeTextCacheManifest
	//
	// English:
	//
	//  Text type 'cache-manifest'
	//
	// Português:
	//
	//  Texto tipo 'cache-manifest'
	KMimeTextCacheManifest Mime = "text/cache-manifest"

	// KMimeTextCalendar
	//
	// English:
	//
	//  Text type 'calendar'
	//
	// Português:
	//
	//  Texto tipo 'calendar'
	KMimeTextCalendar Mime = "text/calendar"

	// KMimeTextCql
	//
	// English:
	//
	//  Text type 'cql'
	//
	// Português:
	//
	//  Texto tipo 'cql'
	KMimeTextCql Mime = "text/cql"

	// KMimeTextCqlExpression
	//
	// English:
	//
	//  Text type 'cql-expression'
	//
	// Português:
	//
	//  Texto tipo 'cql-expression'
	KMimeTextCqlExpression Mime = "text/cql-expression"

	// KMimeTextCqlIdentifier
	//
	// English:
	//
	//  Text type 'cql-identifier'
	//
	// Português:
	//
	//  Texto tipo 'cql-identifier'
	KMimeTextCqlIdentifier Mime = "text/cql-identifier"

	// KMimeTextCss
	//
	// English:
	//
	//  Text type 'css'
	//
	// Português:
	//
	//  Texto tipo 'css'
	KMimeTextCss Mime = "text/css"

	// KMimeTextCsv
	//
	// English:
	//
	//  Text type 'csv'
	//
	// Português:
	//
	//  Texto tipo 'csv'
	KMimeTextCsv Mime = "text/csv"

	// KMimeTextCsvSchema
	//
	// English:
	//
	//  Text type 'csv-schema'
	//
	// Português:
	//
	//  Texto tipo 'csv-schema'
	KMimeTextCsvSchema Mime = "text/csv-schema"

	// KMimeTextDns
	//
	// English:
	//
	//  Text type 'dns'
	//
	// Português:
	//
	//  Texto tipo 'dns'
	KMimeTextDns Mime = "text/dns"

	// KMimeTextEncaprtp
	//
	// English:
	//
	//  Text type 'encaprtp'
	//
	// Português:
	//
	//  Texto tipo 'encaprtp'
	KMimeTextEncaprtp Mime = "text/encaprtp"

	// KMimeTextEnriched
	//
	// English:
	//
	//  Text type 'enriched'
	//
	// Português:
	//
	//  Texto tipo 'enriched'
	KMimeTextEnriched Mime = "[RFC1896]"

	// KMimeTextExample
	//
	// English:
	//
	//  Text type 'example'
	//
	// Português:
	//
	//  Texto tipo 'example'
	KMimeTextExample Mime = "text/example"

	// KMimeTextFhirpath
	//
	// English:
	//
	//  Text type 'fhirpath'
	//
	// Português:
	//
	//  Texto tipo 'fhirpath'
	KMimeTextFhirpath Mime = "text/fhirpath"

	// KMimeTextFlexfec
	//
	// English:
	//
	//  Text type 'flexfec'
	//
	// Português:
	//
	//  Texto tipo 'flexfec'
	KMimeTextFlexfec Mime = "text/flexfec"

	// KMimeTextFwdred
	//
	// English:
	//
	//  Text type 'fwdred'
	//
	// Português:
	//
	//  Texto tipo 'fwdred'
	KMimeTextFwdred Mime = "text/fwdred"

	// KMimeTextGff3
	//
	// English:
	//
	//  Text type 'gff3'
	//
	// Português:
	//
	//  Texto tipo 'gff3'
	KMimeTextGff3 Mime = "text/gff3"

	// KMimeTextGrammarRefList
	//
	// English:
	//
	//  Text type 'grammar-ref-list'
	//
	// Português:
	//
	//  Texto tipo 'grammar-ref-list'
	KMimeTextGrammarRefList Mime = "text/grammar-ref-list"

	// KMimeTextHtml
	//
	// English:
	//
	//  Text type 'html'
	//
	// Português:
	//
	//  Texto tipo 'html'
	KMimeTextHtml Mime = "text/html"

	// KMimeTextJavascript
	//
	// English:
	//
	//  Text type 'javascript'
	//
	// Português:
	//
	//  Texto tipo 'javascript'
	KMimeTextJavascript Mime = "text/javascript"

	// KMimeTextJcrCnd
	//
	// English:
	//
	//  Text type 'jcr-cnd'
	//
	// Português:
	//
	//  Texto tipo 'jcr-cnd'
	KMimeTextJcrCnd Mime = "text/jcr-cnd"

	// KMimeTextMarkdown
	//
	// English:
	//
	//  Text type 'markdown'
	//
	// Português:
	//
	//  Texto tipo 'markdown'
	KMimeTextMarkdown Mime = "text/markdown"

	// KMimeTextMizar
	//
	// English:
	//
	//  Text type 'mizar'
	//
	// Português:
	//
	//  Texto tipo 'mizar'
	KMimeTextMizar Mime = "text/mizar"

	// KMimeTextN3
	//
	// English:
	//
	//  Text type 'n3'
	//
	// Português:
	//
	//  Texto tipo 'n3'
	KMimeTextN3 Mime = "text/n3"

	// KMimeTextParameters
	//
	// English:
	//
	//  Text type 'parameters'
	//
	// Português:
	//
	//  Texto tipo 'parameters'
	KMimeTextParameters Mime = "text/parameters"

	// KMimeTextParityfec
	//
	// English:
	//
	//  Text type 'parityfec'
	//
	// Português:
	//
	//  Texto tipo 'parityfec'
	KMimeTextParityfec Mime = "text/parityfec"

	// KMimeTextPlain
	//
	// English:
	//
	//  Text type 'plain'
	//
	// Português:
	//
	//  Texto tipo 'plain'
	KMimeTextPlain Mime = "[RFC2046][RFC3676][RFC5147]"

	// KMimeTextProvenanceNotation
	//
	// English:
	//
	//  Text type 'provenance-notation'
	//
	// Português:
	//
	//  Texto tipo 'provenance-notation'
	KMimeTextProvenanceNotation Mime = "text/provenance-notation"

	// KMimeTextPrsFallensteinRst
	//
	// English:
	//
	//  Text type 'prs.fallenstein.rst'
	//
	// Português:
	//
	//  Texto tipo 'prs.fallenstein.rst'
	KMimeTextPrsFallensteinRst Mime = "text/prs.fallenstein.rst"

	// KMimeTextPrsLinesTag
	//
	// English:
	//
	//  Text type 'prs.lines.tag'
	//
	// Português:
	//
	//  Texto tipo 'prs.lines.tag'
	KMimeTextPrsLinesTag Mime = "text/prs.lines.tag"

	// KMimeTextPrsPropLogic
	//
	// English:
	//
	//  Text type 'prs.prop.logic'
	//
	// Português:
	//
	//  Texto tipo 'prs.prop.logic'
	KMimeTextPrsPropLogic Mime = "text/prs.prop.logic"

	// KMimeTextRaptorfec
	//
	// English:
	//
	//  Text type 'raptorfec'
	//
	// Português:
	//
	//  Texto tipo 'raptorfec'
	KMimeTextRaptorfec Mime = "text/raptorfec"

	// KMimeTextRED
	//
	// English:
	//
	//  Text type 'RED'
	//
	// Português:
	//
	//  Texto tipo 'RED'
	KMimeTextRED Mime = "text/RED"

	// KMimeTextRfc822Headers
	//
	// English:
	//
	//  Text type 'rfc822-headers'
	//
	// Português:
	//
	//  Texto tipo 'rfc822-headers'
	KMimeTextRfc822Headers Mime = "text/rfc822-headers"

	// KMimeTextRichtext
	//
	// English:
	//
	//  Text type 'richtext'
	//
	// Português:
	//
	//  Texto tipo 'richtext'
	KMimeTextRichtext Mime = "[RFC2045][RFC2046]"

	// KMimeTextRtf
	//
	// English:
	//
	//  Text type 'rtf'
	//
	// Português:
	//
	//  Texto tipo 'rtf'
	KMimeTextRtf Mime = "text/rtf"

	// KMimeTextRtpEncAescm128
	//
	// English:
	//
	//  Text type 'rtp-enc-aescm128'
	//
	// Português:
	//
	//  Texto tipo 'rtp-enc-aescm128'
	KMimeTextRtpEncAescm128 Mime = "text/rtp-enc-aescm128"

	// KMimeTextRtploopback
	//
	// English:
	//
	//  Text type 'rtploopback'
	//
	// Português:
	//
	//  Texto tipo 'rtploopback'
	KMimeTextRtploopback Mime = "text/rtploopback"

	// KMimeTextRtx
	//
	// English:
	//
	//  Text type 'rtx'
	//
	// Português:
	//
	//  Texto tipo 'rtx'
	KMimeTextRtx Mime = "text/rtx"

	// KMimeTextSGML
	//
	// English:
	//
	//  Text type 'SGML'
	//
	// Português:
	//
	//  Texto tipo 'SGML'
	KMimeTextSGML Mime = "text/SGML"

	// KMimeTextShaclc
	//
	// English:
	//
	//  Text type 'shaclc'
	//
	// Português:
	//
	//  Texto tipo 'shaclc'
	KMimeTextShaclc Mime = "text/shaclc"

	// KMimeTextShex
	//
	// English:
	//
	//  Text type 'shex'
	//
	// Português:
	//
	//  Texto tipo 'shex'
	KMimeTextShex Mime = "text/shex"

	// KMimeTextSpdx
	//
	// English:
	//
	//  Text type 'spdx'
	//
	// Português:
	//
	//  Texto tipo 'spdx'
	KMimeTextSpdx Mime = "text/spdx"

	// KMimeTextStrings
	//
	// English:
	//
	//  Text type 'strings'
	//
	// Português:
	//
	//  Texto tipo 'strings'
	KMimeTextStrings Mime = "text/strings"

	// KMimeTextT140
	//
	// English:
	//
	//  Text type 't140'
	//
	// Português:
	//
	//  Texto tipo 't140'
	KMimeTextT140 Mime = "text/t140"

	// KMimeTextTabSeparatedValues
	//
	// English:
	//
	//  Text type 'tab-separated-values'
	//
	// Português:
	//
	//  Texto tipo 'tab-separated-values'
	KMimeTextTabSeparatedValues Mime = "text/tab-separated-values"

	// KMimeTextTroff
	//
	// English:
	//
	//  Text type 'troff'
	//
	// Português:
	//
	//  Texto tipo 'troff'
	KMimeTextTroff Mime = "text/troff"

	// KMimeTextTurtle
	//
	// English:
	//
	//  Text type 'turtle'
	//
	// Português:
	//
	//  Texto tipo 'turtle'
	KMimeTextTurtle Mime = "text/turtle"

	// KMimeTextUlpfec
	//
	// English:
	//
	//  Text type 'ulpfec'
	//
	// Português:
	//
	//  Texto tipo 'ulpfec'
	KMimeTextUlpfec Mime = "text/ulpfec"

	// KMimeTextUriList
	//
	// English:
	//
	//  Text type 'uri-list'
	//
	// Português:
	//
	//  Texto tipo 'uri-list'
	KMimeTextUriList Mime = "text/uri-list"

	// KMimeTextVcard
	//
	// English:
	//
	//  Text type 'vcard'
	//
	// Português:
	//
	//  Texto tipo 'vcard'
	KMimeTextVcard Mime = "text/vcard"

	// KMimeTextVndA
	//
	// English:
	//
	//  Text type 'vnd.a'
	//
	// Português:
	//
	//  Texto tipo 'vnd.a'
	KMimeTextVndA Mime = "text/vnd.a"

	// KMimeTextVndAbc
	//
	// English:
	//
	//  Text type 'vnd.abc'
	//
	// Português:
	//
	//  Texto tipo 'vnd.abc'
	KMimeTextVndAbc Mime = "text/vnd.abc"

	// KMimeTextVndAsciiArt
	//
	// English:
	//
	//  Text type 'vnd.ascii-art'
	//
	// Português:
	//
	//  Texto tipo 'vnd.ascii-art'
	KMimeTextVndAsciiArt Mime = "text/vnd.ascii-art"

	// KMimeTextVndCurl
	//
	// English:
	//
	//  Text type 'vnd.curl'
	//
	// Português:
	//
	//  Texto tipo 'vnd.curl'
	KMimeTextVndCurl Mime = "text/vnd.curl"

	// KMimeTextVndDebianCopyright
	//
	// English:
	//
	//  Text type 'vnd.debian.copyright'
	//
	// Português:
	//
	//  Texto tipo 'vnd.debian.copyright'
	KMimeTextVndDebianCopyright Mime = "text/vnd.debian.copyright"

	// KMimeTextVndDMClientScript
	//
	// English:
	//
	//  Text type 'vnd.DMClientScript'
	//
	// Português:
	//
	//  Texto tipo 'vnd.DMClientScript'
	KMimeTextVndDMClientScript Mime = "text/vnd.DMClientScript"

	// KMimeTextVndDvbSubtitle
	//
	// English:
	//
	//  Text type 'vnd.dvb.subtitle'
	//
	// Português:
	//
	//  Texto tipo 'vnd.dvb.subtitle'
	KMimeTextVndDvbSubtitle Mime = "text/vnd.dvb.subtitle"

	// KMimeTextVndEsmertecThemeDescriptor
	//
	// English:
	//
	//  Text type 'vnd.esmertec.theme-descriptor'
	//
	// Português:
	//
	//  Texto tipo 'vnd.esmertec.theme-descriptor'
	KMimeTextVndEsmertecThemeDescriptor Mime = "text/vnd.esmertec.theme-descriptor"

	// KMimeTextVndFamilysearchGedcom
	//
	// English:
	//
	//  Text type 'vnd.familysearch.gedcom'
	//
	// Português:
	//
	//  Texto tipo 'vnd.familysearch.gedcom'
	KMimeTextVndFamilysearchGedcom Mime = "text/vnd.familysearch.gedcom"

	// KMimeTextVndFiclabFlt
	//
	// English:
	//
	//  Text type 'vnd.ficlab.flt'
	//
	// Português:
	//
	//  Texto tipo 'vnd.ficlab.flt'
	KMimeTextVndFiclabFlt Mime = "text/vnd.ficlab.flt"

	// KMimeTextVndFly
	//
	// English:
	//
	//  Text type 'vnd.fly'
	//
	// Português:
	//
	//  Texto tipo 'vnd.fly'
	KMimeTextVndFly Mime = "text/vnd.fly"

	// KMimeTextVndFmiFlexstor
	//
	// English:
	//
	//  Text type 'vnd.fmi.flexstor'
	//
	// Português:
	//
	//  Texto tipo 'vnd.fmi.flexstor'
	KMimeTextVndFmiFlexstor Mime = "text/vnd.fmi.flexstor"

	// KMimeTextVndGml
	//
	// English:
	//
	//  Text type 'vnd.gml'
	//
	// Português:
	//
	//  Texto tipo 'vnd.gml'
	KMimeTextVndGml Mime = "text/vnd.gml"

	// KMimeTextVndGraphviz
	//
	// English:
	//
	//  Text type 'vnd.graphviz'
	//
	// Português:
	//
	//  Texto tipo 'vnd.graphviz'
	KMimeTextVndGraphviz Mime = "text/vnd.graphviz"

	// KMimeTextVndHans
	//
	// English:
	//
	//  Text type 'vnd.hans'
	//
	// Português:
	//
	//  Texto tipo 'vnd.hans'
	KMimeTextVndHans Mime = "text/vnd.hans"

	// KMimeTextVndHgl
	//
	// English:
	//
	//  Text type 'vnd.hgl'
	//
	// Português:
	//
	//  Texto tipo 'vnd.hgl'
	KMimeTextVndHgl Mime = "text/vnd.hgl"

	// KMimeTextVndIn3d3dml
	//
	// English:
	//
	//  Text type 'vnd.in3d.3dml'
	//
	// Português:
	//
	//  Texto tipo 'vnd.in3d.3dml'
	KMimeTextVndIn3d3dml Mime = "text/vnd.in3d.3dml"

	// KMimeTextVndIn3dSpot
	//
	// English:
	//
	//  Text type 'vnd.in3d.spot'
	//
	// Português:
	//
	//  Texto tipo 'vnd.in3d.spot'
	KMimeTextVndIn3dSpot Mime = "text/vnd.in3d.spot"

	// KMimeTextVndIPTCNewsML
	//
	// English:
	//
	//  Text type 'vnd.IPTC.NewsML'
	//
	// Português:
	//
	//  Texto tipo 'vnd.IPTC.NewsML'
	KMimeTextVndIPTCNewsML Mime = "text/vnd.IPTC.NewsML"

	// KMimeTextVndIPTCNITF
	//
	// English:
	//
	//  Text type 'vnd.IPTC.NITF'
	//
	// Português:
	//
	//  Texto tipo 'vnd.IPTC.NITF'
	KMimeTextVndIPTCNITF Mime = "text/vnd.IPTC.NITF"

	// KMimeTextVndLatexZ
	//
	// English:
	//
	//  Text type 'vnd.latex-z'
	//
	// Português:
	//
	//  Texto tipo 'vnd.latex-z'
	KMimeTextVndLatexZ Mime = "text/vnd.latex-z"

	// KMimeTextVndMotorolaReflex
	//
	// English:
	//
	//  Text type 'vnd.motorola.reflex'
	//
	// Português:
	//
	//  Texto tipo 'vnd.motorola.reflex'
	KMimeTextVndMotorolaReflex Mime = "text/vnd.motorola.reflex"

	// KMimeTextVndMsMediapackage
	//
	// English:
	//
	//  Text type 'vnd.ms-mediapackage'
	//
	// Português:
	//
	//  Texto tipo 'vnd.ms-mediapackage'
	KMimeTextVndMsMediapackage Mime = "text/vnd.ms-mediapackage"

	// KMimeTextVndNet2phoneCommcenterCommand
	//
	// English:
	//
	//  Text type 'vnd.net2phone.commcenter.command'
	//
	// Português:
	//
	//  Texto tipo 'vnd.net2phone.commcenter.command'
	KMimeTextVndNet2phoneCommcenterCommand Mime = "text/vnd.net2phone.commcenter.command"

	// KMimeTextVndRadisysMsmlBasicLayout
	//
	// English:
	//
	//  Text type 'vnd.radisys.msml-basic-layout'
	//
	// Português:
	//
	//  Texto tipo 'vnd.radisys.msml-basic-layout'
	KMimeTextVndRadisysMsmlBasicLayout Mime = "text/vnd.radisys.msml-basic-layout"

	// KMimeTextVndSenxWarpscript
	//
	// English:
	//
	//  Text type 'vnd.senx.warpscript'
	//
	// Português:
	//
	//  Texto tipo 'vnd.senx.warpscript'
	KMimeTextVndSenxWarpscript Mime = "text/vnd.senx.warpscript"

	// KMimeTextVndSunJ2meAppDescriptor
	//
	// English:
	//
	//  Text type 'vnd.sun.j2me.app-descriptor'
	//
	// Português:
	//
	//  Texto tipo 'vnd.sun.j2me.app-descriptor'
	KMimeTextVndSunJ2meAppDescriptor Mime = "text/vnd.sun.j2me.app-descriptor"

	// KMimeTextVndSosi
	//
	// English:
	//
	//  Text type 'vnd.sosi'
	//
	// Português:
	//
	//  Texto tipo 'vnd.sosi'
	KMimeTextVndSosi Mime = "text/vnd.sosi"

	// KMimeTextVndTrolltechLinguist
	//
	// English:
	//
	//  Text type 'vnd.trolltech.linguist'
	//
	// Português:
	//
	//  Texto tipo 'vnd.trolltech.linguist'
	KMimeTextVndTrolltechLinguist Mime = "text/vnd.trolltech.linguist"

	// KMimeTextVndWapSi
	//
	// English:
	//
	//  Text type 'vnd.wap.si'
	//
	// Português:
	//
	//  Texto tipo 'vnd.wap.si'
	KMimeTextVndWapSi Mime = "text/vnd.wap.si"

	// KMimeTextVndWapSl
	//
	// English:
	//
	//  Text type 'vnd.wap.sl'
	//
	// Português:
	//
	//  Texto tipo 'vnd.wap.sl'
	KMimeTextVndWapSl Mime = "text/vnd.wap.sl"

	// KMimeTextVndWapWml
	//
	// English:
	//
	//  Text type 'vnd.wap.wml'
	//
	// Português:
	//
	//  Texto tipo 'vnd.wap.wml'
	KMimeTextVndWapWml Mime = "text/vnd.wap.wml"

	// KMimeTextVndWapWmlscript
	//
	// English:
	//
	//  Text type 'vnd.wap.wmlscript'
	//
	// Português:
	//
	//  Texto tipo 'vnd.wap.wmlscript'
	KMimeTextVndWapWmlscript Mime = "text/vnd.wap.wmlscript"

	// KMimeTextVtt
	//
	// English:
	//
	//  Text type 'vtt'
	//
	// Português:
	//
	//  Texto tipo 'vtt'
	KMimeTextVtt Mime = "text/vtt"

	// KMimeTextXml
	//
	// English:
	//
	//  Text type 'xml'
	//
	// Português:
	//
	//  Texto tipo 'xml'
	KMimeTextXml Mime = "text/xml"

	// KMimeTextXmlExternalParsedEntity
	//
	// English:
	//
	//  Text type 'xml-external-parsed-entity'
	//
	// Português:
	//
	//  Texto tipo 'xml-external-parsed-entity'
	KMimeTextXmlExternalParsedEntity Mime = "text/xml-external-parsed-entity"
)
const (
	// KMimeVideo1dInterleavedParityfec
	//
	// English:
	//
	//  Video type '1d-interleaved-parityfec'
	//
	// Português:
	//
	//  Vídeo tipo '1d-interleaved-parityfec'
	KMimeVideo1dInterleavedParityfec Mime = "video/1d-interleaved-parityfec"

	// KMimeVideo3gpp
	//
	// English:
	//
	//  Video type '3gpp'
	//
	// Português:
	//
	//  Vídeo tipo '3gpp'
	KMimeVideo3gpp Mime = "video/3gpp"

	// KMimeVideo3gpp2
	//
	// English:
	//
	//  Video type '3gpp2'
	//
	// Português:
	//
	//  Vídeo tipo '3gpp2'
	KMimeVideo3gpp2 Mime = "video/3gpp2"

	// KMimeVideo3gppTt
	//
	// English:
	//
	//  Video type '3gpp-tt'
	//
	// Português:
	//
	//  Vídeo tipo '3gpp-tt'
	KMimeVideo3gppTt Mime = "video/3gpp-tt"

	// KMimeVideoAV1
	//
	// English:
	//
	//  Video type 'AV1'
	//
	// Português:
	//
	//  Vídeo tipo 'AV1'
	KMimeVideoAV1 Mime = "video/AV1"

	// KMimeVideoBMPEG
	//
	// English:
	//
	//  Video type 'BMPEG'
	//
	// Português:
	//
	//  Vídeo tipo 'BMPEG'
	KMimeVideoBMPEG Mime = "video/BMPEG"

	// KMimeVideoBT656
	//
	// English:
	//
	//  Video type 'BT656'
	//
	// Português:
	//
	//  Vídeo tipo 'BT656'
	KMimeVideoBT656 Mime = "video/BT656"

	// KMimeVideoCelB
	//
	// English:
	//
	//  Video type 'CelB'
	//
	// Português:
	//
	//  Vídeo tipo 'CelB'
	KMimeVideoCelB Mime = "video/CelB"

	// KMimeVideoDV
	//
	// English:
	//
	//  Video type 'DV'
	//
	// Português:
	//
	//  Vídeo tipo 'DV'
	KMimeVideoDV Mime = "video/DV"

	// KMimeVideoEncaprtp
	//
	// English:
	//
	//  Video type 'encaprtp'
	//
	// Português:
	//
	//  Vídeo tipo 'encaprtp'
	KMimeVideoEncaprtp Mime = "video/encaprtp"

	// KMimeVideoExample
	//
	// English:
	//
	//  Video type 'example'
	//
	// Português:
	//
	//  Vídeo tipo 'example'
	KMimeVideoExample Mime = "video/example"

	// KMimeVideoFFV1
	//
	// English:
	//
	//  Video type 'FFV1'
	//
	// Português:
	//
	//  Vídeo tipo 'FFV1'
	KMimeVideoFFV1 Mime = "video/FFV1"

	// KMimeVideoFlexfec
	//
	// English:
	//
	//  Video type 'flexfec'
	//
	// Português:
	//
	//  Vídeo tipo 'flexfec'
	KMimeVideoFlexfec Mime = "video/flexfec"

	// KMimeVideoH261
	//
	// English:
	//
	//  Video type 'H261'
	//
	// Português:
	//
	//  Vídeo tipo 'H261'
	KMimeVideoH261 Mime = "video/H261"

	// KMimeVideoH263
	//
	// English:
	//
	//  Video type 'H263'
	//
	// Português:
	//
	//  Vídeo tipo 'H263'
	KMimeVideoH263 Mime = "video/H263"

	// KMimeVideoH2631998
	//
	// English:
	//
	//  Video type 'H263-1998'
	//
	// Português:
	//
	//  Vídeo tipo 'H263-1998'
	KMimeVideoH2631998 Mime = "video/H263-1998"

	// KMimeVideoH2632000
	//
	// English:
	//
	//  Video type 'H263-2000'
	//
	// Português:
	//
	//  Vídeo tipo 'H263-2000'
	KMimeVideoH2632000 Mime = "video/H263-2000"

	// KMimeVideoH264
	//
	// English:
	//
	//  Video type 'H264'
	//
	// Português:
	//
	//  Vídeo tipo 'H264'
	KMimeVideoH264 Mime = "video/H264"

	// KMimeVideoH264RCDO
	//
	// English:
	//
	//  Video type 'H264-RCDO'
	//
	// Português:
	//
	//  Vídeo tipo 'H264-RCDO'
	KMimeVideoH264RCDO Mime = "video/H264-RCDO"

	// KMimeVideoH264SVC
	//
	// English:
	//
	//  Video type 'H264-SVC'
	//
	// Português:
	//
	//  Vídeo tipo 'H264-SVC'
	KMimeVideoH264SVC Mime = "video/H264-SVC"

	// KMimeVideoH265
	//
	// English:
	//
	//  Video type 'H265'
	//
	// Português:
	//
	//  Vídeo tipo 'H265'
	KMimeVideoH265 Mime = "video/H265"

	// KMimeVideoIsoSegment
	//
	// English:
	//
	//  Video type 'iso.segment'
	//
	// Português:
	//
	//  Vídeo tipo 'iso.segment'
	KMimeVideoIsoSegment Mime = "video/iso.segment"

	// KMimeVideoJPEG
	//
	// English:
	//
	//  Video type 'JPEG'
	//
	// Português:
	//
	//  Vídeo tipo 'JPEG'
	KMimeVideoJPEG Mime = "video/JPEG"

	// KMimeVideoJpeg2000
	//
	// English:
	//
	//  Video type 'jpeg2000'
	//
	// Português:
	//
	//  Vídeo tipo 'jpeg2000'
	KMimeVideoJpeg2000 Mime = "video/jpeg2000"

	// KMimeVideoJxsv
	//
	// English:
	//
	//  Video type 'jxsv'
	//
	// Português:
	//
	//  Vídeo tipo 'jxsv'
	KMimeVideoJxsv Mime = "video/jxsv"

	// KMimeVideoMj2
	//
	// English:
	//
	//  Video type 'mj2'
	//
	// Português:
	//
	//  Vídeo tipo 'mj2'
	KMimeVideoMj2 Mime = "video/mj2"

	// KMimeVideoMP1S
	//
	// English:
	//
	//  Video type 'MP1S'
	//
	// Português:
	//
	//  Vídeo tipo 'MP1S'
	KMimeVideoMP1S Mime = "video/MP1S"

	// KMimeVideoMP2P
	//
	// English:
	//
	//  Video type 'MP2P'
	//
	// Português:
	//
	//  Vídeo tipo 'MP2P'
	KMimeVideoMP2P Mime = "video/MP2P"

	// KMimeVideoMP2T
	//
	// English:
	//
	//  Video type 'MP2T'
	//
	// Português:
	//
	//  Vídeo tipo 'MP2T'
	KMimeVideoMP2T Mime = "video/MP2T"

	// KMimeVideoMp4
	//
	// English:
	//
	//  Video type 'mp4'
	//
	// Português:
	//
	//  Vídeo tipo 'mp4'
	KMimeVideoMp4 Mime = "video/mp4"

	// KMimeVideoMP4VES
	//
	// English:
	//
	//  Video type 'MP4V-ES'
	//
	// Português:
	//
	//  Vídeo tipo 'MP4V-ES'
	KMimeVideoMP4VES Mime = "video/MP4V-ES"

	// KMimeVideoMPV
	//
	// English:
	//
	//  Video type 'MPV'
	//
	// Português:
	//
	//  Vídeo tipo 'MPV'
	KMimeVideoMPV Mime = "video/MPV"

	// KMimeVideoMpeg
	//
	// English:
	//
	//  Video type 'mpeg'
	//
	// Português:
	//
	//  Vídeo tipo 'mpeg'
	KMimeVideoMpeg Mime = "[RFC2045][RFC2046]"

	// KMimeVideoMpeg4Generic
	//
	// English:
	//
	//  Video type 'mpeg4-generic'
	//
	// Português:
	//
	//  Vídeo tipo 'mpeg4-generic'
	KMimeVideoMpeg4Generic Mime = "video/mpeg4-generic"

	// KMimeVideoNv
	//
	// English:
	//
	//  Video type 'nv'
	//
	// Português:
	//
	//  Vídeo tipo 'nv'
	KMimeVideoNv Mime = "video/nv"

	// KMimeVideoOgg
	//
	// English:
	//
	//  Video type 'ogg'
	//
	// Português:
	//
	//  Vídeo tipo 'ogg'
	KMimeVideoOgg Mime = "video/ogg"

	// KMimeVideoParityfec
	//
	// English:
	//
	//  Video type 'parityfec'
	//
	// Português:
	//
	//  Vídeo tipo 'parityfec'
	KMimeVideoParityfec Mime = "video/parityfec"

	// KMimeVideoPointer
	//
	// English:
	//
	//  Video type 'pointer'
	//
	// Português:
	//
	//  Vídeo tipo 'pointer'
	KMimeVideoPointer Mime = "video/pointer"

	// KMimeVideoQuicktime
	//
	// English:
	//
	//  Video type 'quicktime'
	//
	// Português:
	//
	//  Vídeo tipo 'quicktime'
	KMimeVideoQuicktime Mime = "video/quicktime"

	// KMimeVideoRaptorfec
	//
	// English:
	//
	//  Video type 'raptorfec'
	//
	// Português:
	//
	//  Vídeo tipo 'raptorfec'
	KMimeVideoRaptorfec Mime = "video/raptorfec"

	// KMimeVideoRaw
	//
	// English:
	//
	//  Video type 'raw'
	//
	// Português:
	//
	//  Vídeo tipo 'raw'
	KMimeVideoRaw Mime = "video/raw"

	// KMimeVideoRtpEncAescm128
	//
	// English:
	//
	//  Video type 'rtp-enc-aescm128'
	//
	// Português:
	//
	//  Vídeo tipo 'rtp-enc-aescm128'
	KMimeVideoRtpEncAescm128 Mime = "video/rtp-enc-aescm128"

	// KMimeVideoRtploopback
	//
	// English:
	//
	//  Video type 'rtploopback'
	//
	// Português:
	//
	//  Vídeo tipo 'rtploopback'
	KMimeVideoRtploopback Mime = "video/rtploopback"

	// KMimeVideoRtx
	//
	// English:
	//
	//  Video type 'rtx'
	//
	// Português:
	//
	//  Vídeo tipo 'rtx'
	KMimeVideoRtx Mime = "video/rtx"

	// KMimeVideoScip
	//
	// English:
	//
	//  Video type 'scip'
	//
	// Português:
	//
	//  Vídeo tipo 'scip'
	KMimeVideoScip Mime = "video/scip"

	// KMimeVideoSmpte291
	//
	// English:
	//
	//  Video type 'smpte291'
	//
	// Português:
	//
	//  Vídeo tipo 'smpte291'
	KMimeVideoSmpte291 Mime = "video/smpte291"

	// KMimeVideoSMPTE292M
	//
	// English:
	//
	//  Video type 'SMPTE292M'
	//
	// Português:
	//
	//  Vídeo tipo 'SMPTE292M'
	KMimeVideoSMPTE292M Mime = "video/SMPTE292M"

	// KMimeVideoUlpfec
	//
	// English:
	//
	//  Video type 'ulpfec'
	//
	// Português:
	//
	//  Vídeo tipo 'ulpfec'
	KMimeVideoUlpfec Mime = "video/ulpfec"

	// KMimeVideoVc1
	//
	// English:
	//
	//  Video type 'vc1'
	//
	// Português:
	//
	//  Vídeo tipo 'vc1'
	KMimeVideoVc1 Mime = "video/vc1"

	// KMimeVideoVc2
	//
	// English:
	//
	//  Video type 'vc2'
	//
	// Português:
	//
	//  Vídeo tipo 'vc2'
	KMimeVideoVc2 Mime = "video/vc2"

	// KMimeVideoVndCCTV
	//
	// English:
	//
	//  Video type 'vnd.CCTV'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.CCTV'
	KMimeVideoVndCCTV Mime = "video/vnd.CCTV"

	// KMimeVideoVndDeceHd
	//
	// English:
	//
	//  Video type 'vnd.dece.hd'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.dece.hd'
	KMimeVideoVndDeceHd Mime = "video/vnd.dece.hd"

	// KMimeVideoVndDeceMobile
	//
	// English:
	//
	//  Video type 'vnd.dece.mobile'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.dece.mobile'
	KMimeVideoVndDeceMobile Mime = "video/vnd.dece.mobile"

	// KMimeVideoVndDeceMp4
	//
	// English:
	//
	//  Video type 'vnd.dece.mp4'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.dece.mp4'
	KMimeVideoVndDeceMp4 Mime = "video/vnd.dece.mp4"

	// KMimeVideoVndDecePd
	//
	// English:
	//
	//  Video type 'vnd.dece.pd'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.dece.pd'
	KMimeVideoVndDecePd Mime = "video/vnd.dece.pd"

	// KMimeVideoVndDeceSd
	//
	// English:
	//
	//  Video type 'vnd.dece.sd'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.dece.sd'
	KMimeVideoVndDeceSd Mime = "video/vnd.dece.sd"

	// KMimeVideoVndDeceVideo
	//
	// English:
	//
	//  Video type 'vnd.dece.video'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.dece.video'
	KMimeVideoVndDeceVideo Mime = "video/vnd.dece.video"

	// KMimeVideoVndDirectvMpeg
	//
	// English:
	//
	//  Video type 'vnd.directv.mpeg'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.directv.mpeg'
	KMimeVideoVndDirectvMpeg Mime = "video/vnd.directv.mpeg"

	// KMimeVideoVndDirectvMpegTts
	//
	// English:
	//
	//  Video type 'vnd.directv.mpeg-tts'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.directv.mpeg-tts'
	KMimeVideoVndDirectvMpegTts Mime = "video/vnd.directv.mpeg-tts"

	// KMimeVideoVndDlnaMpegTts
	//
	// English:
	//
	//  Video type 'vnd.dlna.mpeg-tts'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.dlna.mpeg-tts'
	KMimeVideoVndDlnaMpegTts Mime = "video/vnd.dlna.mpeg-tts"

	// KMimeVideoVndDvbFile
	//
	// English:
	//
	//  Video type 'vnd.dvb.file'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.dvb.file'
	KMimeVideoVndDvbFile Mime = "video/vnd.dvb.file"

	// KMimeVideoVndFvt
	//
	// English:
	//
	//  Video type 'vnd.fvt'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.fvt'
	KMimeVideoVndFvt Mime = "video/vnd.fvt"

	// KMimeVideoVndHnsVideo
	//
	// English:
	//
	//  Video type 'vnd.hns.video'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.hns.video'
	KMimeVideoVndHnsVideo Mime = "video/vnd.hns.video"

	// KMimeVideoVndIptvforum1dparityfec1010
	//
	// English:
	//
	//  Video type 'vnd.iptvforum.1dparityfec-1010'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.iptvforum.1dparityfec-1010'
	KMimeVideoVndIptvforum1dparityfec1010 Mime = "video/vnd.iptvforum.1dparityfec-1010"

	// KMimeVideoVndIptvforum1dparityfec2005
	//
	// English:
	//
	//  Video type 'vnd.iptvforum.1dparityfec-2005'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.iptvforum.1dparityfec-2005'
	KMimeVideoVndIptvforum1dparityfec2005 Mime = "video/vnd.iptvforum.1dparityfec-2005"

	// KMimeVideoVndIptvforum2dparityfec1010
	//
	// English:
	//
	//  Video type 'vnd.iptvforum.2dparityfec-1010'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.iptvforum.2dparityfec-1010'
	KMimeVideoVndIptvforum2dparityfec1010 Mime = "video/vnd.iptvforum.2dparityfec-1010"

	// KMimeVideoVndIptvforum2dparityfec2005
	//
	// English:
	//
	//  Video type 'vnd.iptvforum.2dparityfec-2005'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.iptvforum.2dparityfec-2005'
	KMimeVideoVndIptvforum2dparityfec2005 Mime = "video/vnd.iptvforum.2dparityfec-2005"

	// KMimeVideoVndIptvforumTtsavc
	//
	// English:
	//
	//  Video type 'vnd.iptvforum.ttsavc'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.iptvforum.ttsavc'
	KMimeVideoVndIptvforumTtsavc Mime = "video/vnd.iptvforum.ttsavc"

	// KMimeVideoVndIptvforumTtsmpeg2
	//
	// English:
	//
	//  Video type 'vnd.iptvforum.ttsmpeg2'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.iptvforum.ttsmpeg2'
	KMimeVideoVndIptvforumTtsmpeg2 Mime = "video/vnd.iptvforum.ttsmpeg2"

	// KMimeVideoVndMotorolaVideo
	//
	// English:
	//
	//  Video type 'vnd.motorola.video'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.motorola.video'
	KMimeVideoVndMotorolaVideo Mime = "video/vnd.motorola.video"

	// KMimeVideoVndMotorolaVideop
	//
	// English:
	//
	//  Video type 'vnd.motorola.videop'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.motorola.videop'
	KMimeVideoVndMotorolaVideop Mime = "video/vnd.motorola.videop"

	// KMimeVideoVndMpegurl
	//
	// English:
	//
	//  Video type 'vnd.mpegurl'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.mpegurl'
	KMimeVideoVndMpegurl Mime = "video/vnd.mpegurl"

	// KMimeVideoVndMsPlayreadyMediaPyv
	//
	// English:
	//
	//  Video type 'vnd.ms-playready.media.pyv'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.ms-playready.media.pyv'
	KMimeVideoVndMsPlayreadyMediaPyv Mime = "video/vnd.ms-playready.media.pyv"

	// KMimeVideoVndNokiaInterleavedMultimedia
	//
	// English:
	//
	//  Video type 'vnd.nokia.interleaved-multimedia'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.nokia.interleaved-multimedia'
	KMimeVideoVndNokiaInterleavedMultimedia Mime = "video/vnd.nokia.interleaved-multimedia"

	// KMimeVideoVndNokiaMp4vr
	//
	// English:
	//
	//  Video type 'vnd.nokia.mp4vr'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.nokia.mp4vr'
	KMimeVideoVndNokiaMp4vr Mime = "video/vnd.nokia.mp4vr"

	// KMimeVideoVndNokiaVideovoip
	//
	// English:
	//
	//  Video type 'vnd.nokia.videovoip'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.nokia.videovoip'
	KMimeVideoVndNokiaVideovoip Mime = "video/vnd.nokia.videovoip"

	// KMimeVideoVndObjectvideo
	//
	// English:
	//
	//  Video type 'vnd.objectvideo'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.objectvideo'
	KMimeVideoVndObjectvideo Mime = "video/vnd.objectvideo"

	// KMimeVideoVndRadgamettoolsBink
	//
	// English:
	//
	//  Video type 'vnd.radgamettools.bink'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.radgamettools.bink'
	KMimeVideoVndRadgamettoolsBink Mime = "video/vnd.radgamettools.bink"

	// KMimeVideoVndRadgamettoolsSmacker
	//
	// English:
	//
	//  Video type 'vnd.radgamettools.smacker'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.radgamettools.smacker'
	KMimeVideoVndRadgamettoolsSmacker Mime = "video/vnd.radgamettools.smacker"

	// KMimeVideoVndSealedMpeg1
	//
	// English:
	//
	//  Video type 'vnd.sealed.mpeg1'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.sealed.mpeg1'
	KMimeVideoVndSealedMpeg1 Mime = "video/vnd.sealed.mpeg1"

	// KMimeVideoVndSealedMpeg4
	//
	// English:
	//
	//  Video type 'vnd.sealed.mpeg4'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.sealed.mpeg4'
	KMimeVideoVndSealedMpeg4 Mime = "video/vnd.sealed.mpeg4"

	// KMimeVideoVndSealedSwf
	//
	// English:
	//
	//  Video type 'vnd.sealed.swf'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.sealed.swf'
	KMimeVideoVndSealedSwf Mime = "video/vnd.sealed.swf"

	// KMimeVideoVndSealedmediaSoftsealMov
	//
	// English:
	//
	//  Video type 'vnd.sealedmedia.softseal.mov'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.sealedmedia.softseal.mov'
	KMimeVideoVndSealedmediaSoftsealMov Mime = "video/vnd.sealedmedia.softseal.mov"

	// KMimeVideoVndUvvuMp4
	//
	// English:
	//
	//  Video type 'vnd.uvvu.mp4'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.uvvu.mp4'
	KMimeVideoVndUvvuMp4 Mime = "video/vnd.uvvu.mp4"

	// KMimeVideoVndYoutubeYt
	//
	// English:
	//
	//  Video type 'vnd.youtube.yt'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.youtube.yt'
	KMimeVideoVndYoutubeYt Mime = "video/vnd.youtube.yt"

	// KMimeVideoVndVivo
	//
	// English:
	//
	//  Video type 'vnd.vivo'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.vivo'
	KMimeVideoVndVivo Mime = "video/vnd.vivo"

	// KMimeVideoVP8
	//
	// English:
	//
	//  Video type 'VP8'
	//
	// Português:
	//
	//  Vídeo tipo 'VP8'
	KMimeVideoVP8 Mime = "video/VP8"

	// KMimeVideoVP9
	//
	// English:
	//
	//  Video type 'VP9'
	//
	// Português:
	//
	//  Vídeo tipo 'VP9'
	KMimeVideoVP9 Mime = "video/VP9"
)

func (Mime) String 

func (e Mime) String() string

type Overflow 

type Overflow string
const (
	KOverflowVisible Overflow = "visible"
	KOverflowHidden  Overflow = "hidden"
	KOverflowScroll  Overflow = "scroll"
	KOverflowAuto    Overflow = "auto"
)

func (Overflow) String 

func (e Overflow) String() string

type PositionHorizontal 

type PositionHorizontal string
const (
	// KPositionHorizontalLeft
	//
	// English:
	//
	// The reference point of the marker is placed at the left edge of the shape.
	//
	// Português:
	//
	// O ponto de referência do marcador é colocado na borda esquerda da forma.
	KPositionHorizontalLeft PositionHorizontal = "left"

	// KPositionHorizontalCenter
	//
	// English:
	//
	// The reference point of the marker is placed at the horizontal center of the shape.
	//
	// Português:
	//
	// O ponto de referência do marcador é colocado no centro horizontal da forma.
	KPositionHorizontalCenter PositionHorizontal = "center"

	// KPositionHorizontalRight
	//
	// English:
	//
	// The reference point of the marker is placed at the right edge of the shape.
	//
	// Português:
	//
	// O ponto de referência do marcador é colocado na borda direita da forma.
	KPositionHorizontalRight PositionHorizontal = "right"
)

func (PositionHorizontal) String 

func (e PositionHorizontal) String() string

type PositionVertical 

type PositionVertical string
const (
	// KPositionVerticalTop
	//
	// English:
	//
	// The reference point of the marker is placed at the top edge of the shape.
	//
	// Português:
	//
	// O ponto de referência do marcador é colocado na borda superior da forma.
	KPositionVerticalTop PositionVertical = "top"

	// KPositionVerticalCenter
	//
	// English:
	//
	// The reference point of the marker is placed at the vertical center of the shape.
	//
	// Português:
	//
	// O ponto de referência do marcador é colocado no centro vertical da forma.
	KPositionVerticalCenter PositionVertical = "center"

	// KPositionVerticalBottom
	//
	// English:
	//
	// The reference point of the marker is placed at the bottom edge of the shape.
	//
	// Português:
	//
	// O ponto de referência do marcador é colocado na borda inferior da forma.
	KPositionVerticalBottom PositionVertical = "bottom"
)

func (PositionVertical) String 

func (e PositionVertical) String() string

type Ratio 

type Ratio string

Ratio

English: 

The alignment value indicates whether to force uniform scaling and, if so, the alignment method to use in case the
aspect ratio of the viewBox doesn't match the aspect ratio of the viewport.

Português: 

O valor de alinhamento indica se deve-se forçar o dimensionamento uniforme e, em caso afirmativo, o método de
alinhamento a ser usado caso a proporção da viewBox não corresponda à proporção da janela de visualização.

const (
	// KRatioNone
	//
	// English:
	//
	//  Do not force uniform scaling.
	//
	// Scale the graphic content of the given element non-uniformly if necessary such that the element's bounding box
	// exactly matches the viewport rectangle.
	//
	// Note that if <align> is none, then the optional <meetOrSlice> value is ignored.
	//
	// Português:
	//
	//  Não force a escala uniforme.
	//
	// Dimensione o conteúdo gráfico do elemento fornecido de forma não uniforme, se necessário, de modo que a caixa
	// delimitadora do elemento corresponda exatamente ao retângulo da janela de visualização.
	//
	// Observe que se <align> for none, o valor opcional <meetOrSlice> será ignorado.
	KRatioNone Ratio = "none"

	// KRatioXMinYMin
	//
	// English:
	//
	//  Force uniform scaling.
	//
	// Align the <min-x> of the element's viewBox with the smallest X value of the viewport.
	//
	// Align the <min-y> of the element's viewBox with the smallest Y value of the viewport.
	//
	// Português:
	//
	//  Forçar escala uniforme.
	//
	// Alinhe o <min-x> da viewBox do elemento com o menor valor X da viewport.
	//
	// Alinhe o <min-y> da viewBox do elemento com o menor valor Y da viewport.
	KRatioXMinYMin Ratio = "xMinYMin"

	// KRatioXMidYMin
	//
	// English:
	//
	//  Force uniform scaling.
	//
	// Align the midpoint X value of the element's viewBox with the midpoint X value of the viewport.
	//
	// Align the <min-y> of the element's viewBox with the smallest Y value of the viewport.
	//
	// Português:
	//
	//  Forçar escala uniforme.
	//
	// Alinhe o valor X do ponto médio da viewBox do elemento com o valor X do ponto médio da viewport.
	//
	// Alinhe o <min-y> da viewBox do elemento com o menor valor Y da viewport.
	KRatioXMidYMin Ratio = "xMidYMin"

	// KRatioXMaxYMin
	//
	// English:
	//
	//  Force uniform scaling.
	//
	// Align the <min-x>+<width> of the element's viewBox with the maximum X value of the viewport.
	//
	// Align the <min-y> of the element's viewBox with the smallest Y value of the viewport.
	//
	// Português:
	//
	//  Forçar escala uniforme.
	//
	// Alinhe o <min-x>+<width> da viewBox do elemento com o valor X máximo da viewport.
	//
	// Alinhe o <min-y> da viewBox do elemento com o menor valor Y da viewport.
	KRatioXMaxYMin Ratio = "xMaxYMin"

	// KRatioXMinYMid
	//
	// English:
	//
	//  Force uniform scaling.
	//
	// Align the <min-x> of the element's viewBox with the smallest X value of the viewport.
	//
	// Align the midpoint Y value of the element's viewBox with the midpoint Y value of the viewport.
	//
	// Português:
	//
	//  Forçar escala uniforme.
	//
	// Alinhe o <min-x> da viewBox do elemento com o menor valor X da viewport.
	//
	// Alinhe o valor Y do ponto médio da viewBox do elemento com o valor Y do ponto médio da viewport.
	KRatioXMinYMid Ratio = "xMinYMid"

	// KRatioXMidYMid
	//
	// English:
	//
	//  Force uniform scaling.
	//
	// Align the midpoint X value of the element's viewBox with the midpoint X value of the viewport.
	//
	// Align the midpoint Y value of the element's viewBox with the midpoint Y value of the viewport.
	//
	// Português:
	//
	//  Forçar escala uniforme.
	//
	// Alinhe o valor X do ponto médio da viewBox do elemento com o valor X do ponto médio da viewport.
	//
	// Alinhe o valor Y do ponto médio da viewBox do elemento com o valor Y do ponto médio da viewport.
	KRatioXMidYMid Ratio = "xMidYMid"

	// KRatioXMaxYMid
	//
	// English:
	//
	//  Force uniform scaling.
	//
	// Align the <min-x>+<width> of the element's viewBox with the maximum X value of the viewport.
	//
	// Align the midpoint Y value of the element's viewBox with the midpoint Y value of the viewport.
	//
	// Português:
	//
	//  Forçar escala uniforme.
	//
	// Alinhe o <min-x>+<width> da viewBox do elemento com o valor X máximo da viewport.
	//
	// Alinhe o valor Y do ponto médio da viewBox do elemento com o valor Y do ponto médio da viewport.
	KRatioXMaxYMid Ratio = "xMaxYMid"

	// KRatioXMinYMax
	//
	// English:
	//
	//  Force uniform scaling.
	//
	// Align the <min-x> of the element's viewBox with the smallest X value of the viewport.
	//
	// Align the <min-y>+<height> of the element's viewBox with the maximum Y value of the viewport.
	//
	// Português:
	//
	//  Forçar escala uniforme.
	//
	// Alinhe o <min-x> da viewBox do elemento com o menor valor X da viewport.
	//
	// Alinhe o <min-y>+<height> da viewBox do elemento com o valor Y máximo da viewport.
	KRatioXMinYMax Ratio = "xMinYMax"

	// KRatioXMidYMax
	//
	// English:
	//
	//  Force uniform scaling.
	//
	// Align the midpoint X value of the element's viewBox with the midpoint X value of the viewport.
	//
	// Align the <min-y>+<height> of the element's viewBox with the maximum Y value of the viewport.
	//
	// Português:
	//
	//  Forçar escala uniforme.
	//
	// Alinhe o valor X do ponto médio da viewBox do elemento com o valor X do ponto médio da viewport.
	//
	// Alinhe o <min-y>+<height> da viewBox do elemento com o valor Y máximo da viewport.
	KRatioXMidYMax Ratio = "xMidYMax"

	// KRatioXMaxYMax
	//
	// English:
	//
	//  Force uniform scaling.
	//
	// Align the <min-x>+<width> of the element's viewBox with the maximum X value of the viewport.
	//
	// Align the <min-y>+<height> of the element's viewBox with the maximum Y value of the viewport.
	//
	// Português:
	//
	//  Forçar escala uniforme.
	//
	// Alinhe o <min-x>+<width> da viewBox do elemento com o valor X máximo da viewport.
	//
	// Alinhe o <min-y>+<height> da viewBox do elemento com o valor Y máximo da viewport.
	KRatioXMaxYMax Ratio = "xMaxYMax"
)

func (Ratio) String 

func (e Ratio) String() string

type ReferrerPolicy 

type ReferrerPolicy string
const (
	// KRefPolicyNoReferrer
	//
	// English:
	//
	//  The Referer header will not be sent.
	//
	// Português:
	//
	//  O cabeçalho Referer não será enviado.
	KRefPolicyNoReferrer ReferrerPolicy = "no-referrer"

	// KRefPolicyNoReferrerWhenDowngrade
	//
	// English:
	//
	//  The Referer header will not be sent to origins without TLS (HTTPS).
	//
	// Português:
	//
	//  O cabeçalho Referer não será enviado para origens sem TLS (HTTPS).
	KRefPolicyNoReferrerWhenDowngrade ReferrerPolicy = "no-referrer-when-downgrade"

	// KRefPolicyOrigin
	//
	// English:
	//
	//  The sent referrer will be limited to the origin of the referring page: its scheme, host, and
	//  port.
	//
	// Português:
	//
	//  O referenciador enviado será limitado à origem da página de referência: seu esquema, host e
	//  porta.
	KRefPolicyOrigin ReferrerPolicy = "origin"

	// KRefPolicyOriginWhenCrossOrigin
	//
	// English:
	//
	//  The referrer sent to other origins will be limited to the scheme, the host, and the port.
	//  Navigations on the same origin will still include the path.
	//
	// Português:
	//
	//  O referenciador enviado para outras origens será limitado ao esquema, ao host e à porta.
	//  As navegações na mesma origem ainda incluirão o caminho.
	KRefPolicyOriginWhenCrossOrigin ReferrerPolicy = "origin-when-cross-origin"

	// KRefPolicySameOrigin
	//
	// English:
	//
	//  A referrer will be sent for same origin, but cross-origin requests will contain no referrer
	//  information.
	//
	// Português:
	//
	//  Um referenciador será enviado para a mesma origem, mas as solicitações de origem cruzada não
	//  conterão informações de referenciador.
	KRefPolicySameOrigin ReferrerPolicy = "same-origin"

	// KRefPolicyStrictOrigin
	//
	// English:
	//
	//  Only send the origin of the document as the referrer when the protocol security level stays the
	//  same (HTTPS→HTTPS), but don't send it to a less secure destination (HTTPS→HTTP).
	//
	// Português:
	//
	//  Só envie a origem do documento como referenciador quando o nível de segurança do protocolo
	//  permanecer o mesmo (HTTPS→HTTPS), mas não envie para um destino menos seguro (HTTPS→HTTP).
	KRefPolicyStrictOrigin ReferrerPolicy = "strict-origin"

	// KRefPolicyStrictOriginWhenCrossOrigin
	//
	// English:
	//
	//  Send a full URL when performing a same-origin request, only send the origin when the protocol
	//  security level stays the same (HTTPS→HTTPS), and send no header to a less secure destination
	//  (HTTPS→HTTP). (default)
	//
	// Português:
	//
	//  Envie uma URL completa ao realizar uma solicitação de mesma origem, envie a origem apenas quando
	//  o nível de segurança do protocolo permanecer o mesmo (HTTPS→HTTPS) e não envie nenhum cabeçalho
	//  para um destino menos seguro (HTTPS→HTTP). (padrão)
	KRefPolicyStrictOriginWhenCrossOrigin ReferrerPolicy = "strict-origin-when-cross-origin"

	// KRefPolicyUnsafeUrl
	//
	// English:
	//
	//  The referrer will include the origin and the path (but not the fragment, password, or username).
	//  This value is unsafe, because it leaks origins and paths from TLS-protected resources to
	//  insecure origins.
	//
	// Português:
	//
	//  O referenciador incluirá a origem e o caminho (mas não o fragmento, a senha ou o nome de
	//  usuário).
	//  Esse valor não é seguro porque vaza origens e caminhos de recursos protegidos por TLS para
	//  origens inseguras.
	KRefPolicyUnsafeUrl ReferrerPolicy = "unsafe-url"
)

func (ReferrerPolicy) String 

func (e ReferrerPolicy) String() string

type Scheme 

type Scheme string
const (
	KSchemeBitcoin     Scheme = "bitcoin"
	KSchemeFtp         Scheme = "ftp"
	KSchemeFtps        Scheme = "ftps"
	KSchemeGeo         Scheme = "geo"
	KSchemeIm          Scheme = "im"
	KSchemeIrc         Scheme = "irc"
	KSchemeIrcs        Scheme = "ircs"
	KSchemeMagnet      Scheme = "magnet"
	KSchemeMailTo      Scheme = "mailto"
	KSchemeMatrix      Scheme = "matrix"
	KSchemeMms         Scheme = "mms"
	KSchemeNews        Scheme = "news"
	KSchemeNntp        Scheme = "nntp"
	KSchemeOpenPgp4Fpr Scheme = "openpgp4fpr"
	KSchemeSftp        Scheme = "sftp"
	KSchemeSip         Scheme = "sip"
	KSchemeSms         Scheme = "sms"
	KSchemeSmsTo       Scheme = "smsto"
	KSchemeSsh         Scheme = "ssh"
	KSchemeTel         Scheme = "tel"
	KSchemeUrn         Scheme = "urn"
	KSchemeWebCal      Scheme = "webcal"
	KSchemeWtai        Scheme = "wtai"
	KSchemeXmpp        Scheme = "xmpp"
)

func (Scheme) String 

func (e Scheme) String() string

type SvgAccumulate 

type SvgAccumulate string
const (

	// KSvgAccumulateSum
	//
	// English:
	//
	//  Specifies that each repeat iteration after the first builds upon the last value of the previous iteration.
	//
	// Português:
	//
	//  Especifica que cada iteração repetida após a primeira se baseia no último valor da iteração anterior.
	KSvgAccumulateSum SvgAccumulate = "sum"

	// KSvgAccumulateNone
	//
	// English:
	//
	//  Specifies that repeat iterations are not cumulative.
	//
	// Português:
	//
	//  Especifica que as iterações repetidas não são cumulativas.
	KSvgAccumulateNone SvgAccumulate = "none"
)

func (SvgAccumulate) String 

func (e SvgAccumulate) String() string

type SvgAdditive 

type SvgAdditive string
const (

	// KSvgAdditiveSum
	//
	// English:
	//
	//  Specifies that the animation will add to the underlying value of the attribute and other lower priority
	//  animations.
	//
	// Português:
	//
	//  Especifica que a animação será adicionada ao valor subjacente do atributo e outras animações de prioridade mais
	//  baixa.
	KSvgAdditiveSum SvgAdditive = "sum"

	// KSvgAdditiveReplace
	//
	// English:
	//
	//  Specifies that the animation will override the underlying value of the attribute and other lower priority
	//  animations.
	//
	// This is the default, however the behavior is also affected by the animation value attributes by and to, as
	// described in SMIL Animation: How from, to and by attributes affect additive behavior.
	//
	// Português:
	//
	//  Especifica que a animação substituirá o valor subjacente do atributo e outras animações de prioridade mais baixa.
	//
	// Este é o padrão, no entanto, o comportamento também é afetado pelos atributos de valor de animação por e para,
	// conforme descrito em Animação SMIL: Como os atributos de, para e por afetam o comportamento aditivo.
	KSvgAdditiveReplace SvgAdditive = "replace"
)

func (SvgAdditive) String 

func (e SvgAdditive) String() string

type SvgAlignmentBaseline 

type SvgAlignmentBaseline string
const (
	// KSvgAlignmentBaselineBaseline
	//
	// English:
	//
	//  Uses the dominant baseline choice of the parent. Matches the box's corresponding baseline to that of its parent.
	//
	// Português:
	//
	//  Usa a escolha de linha de base dominante do pai. Corresponde à linha de base correspondente da caixa à de seu pai.
	KSvgAlignmentBaselineBaseline SvgAlignmentBaseline = "baseline"

	// KSvgAlignmentBaselineTextBottom
	//
	// English:
	//
	//  Matches the bottom of the box to the top of the parent's content area.
	//
	// Português:
	//
	//  Corresponde a parte inferior da caixa à parte superior da área de conteúdo do pai.
	KSvgAlignmentBaselineTextBottom SvgAlignmentBaseline = "text-bottom"

	// KSvgAlignmentBaselineTextBeforeEdge
	//
	// English:
	//
	//  The alignment-point of the object being aligned is aligned with the "text-before-edge" baseline of the parent text content element.
	//
	//   Notes:
	//
	//     * This keyword may be mapped to text-top.
	//
	// Português:
	//
	//  O ponto de alinhamento do objeto que está sendo alinhado é alinhado com a linha de base "text-before-edge" do elemento de conteúdo de texto pai.
	//
	//   Notas:
	//
	//     * Esta palavra-chave pode ser mapeada para text-top.
	KSvgAlignmentBaselineTextBeforeEdge SvgAlignmentBaseline = "text-before-edge"

	// KSvgAlignmentBaselineMiddle
	//
	// English:
	//
	//  Aligns the vertical midpoint of the box with the baseline of the parent box plus half the x-height of the parent.
	//
	// Português:
	//
	//  Alinha o ponto médio vertical da caixa com a linha de base da caixa pai mais metade da altura x do pai.
	KSvgAlignmentBaselineMiddle SvgAlignmentBaseline = "middle"

	// KSvgAlignmentBaselineCentral
	//
	// English:
	//
	//  Matches the box's central baseline to the central baseline of its parent.
	//
	// Português:
	//
	//  Corresponde a linha de base central da caixa à linha de base central de seu pai.
	KSvgAlignmentBaselineCentral SvgAlignmentBaseline = "central"

	// KSvgAlignmentBaselineTextTop
	//
	// English:
	//
	//  Matches the top of the box to the top of the parent's content area.
	//
	// Português:
	//
	//  Corresponde a parte superior da caixa à parte superior da área de conteúdo do pai.
	KSvgAlignmentBaselineTextTop SvgAlignmentBaseline = "text-top"

	// KSvgAlignmentBaselineTextAfterEdge
	//
	// English:
	//
	//  The alignment-point of the object being aligned is aligned with the "text-after-edge" baseline of the parent text content element.
	//
	//   Notes:
	//     * This keyword may be mapped to text-bottom.
	//
	// Português:
	//
	//  O ponto de alinhamento do objeto que está sendo alinhado é alinhado com a linha de base "text-after-edge" do elemento de conteúdo de texto pai.
	//
	//   Notas:
	//     * Esta palavra-chave pode ser mapeada para text-bottom.
	KSvgAlignmentBaselineTextAfterEdge SvgAlignmentBaseline = "text-after-edge"

	// KSvgAlignmentBaselineIdeographic
	//
	// English:
	//
	//  Matches the box's ideographic character face under-side baseline to that of its parent.
	//
	// Português:
	//
	//  Corresponde à linha de base do lado inferior da face do caractere ideográfico da caixa com a de seu pai.
	KSvgAlignmentBaselineIdeographic SvgAlignmentBaseline = "ideographic"

	// KSvgAlignmentBaselineAlphabetic
	//
	// English:
	//
	//  Matches the box's alphabetic baseline to that of its parent.
	//
	// Português:
	//
	//  Corresponde a linha de base alfabética da caixa à de seu pai.
	KSvgAlignmentBaselineAlphabetic SvgAlignmentBaseline = "alphabetic"

	// KSvgAlignmentBaselineHanging
	//
	// English:
	//
	//  The alignment-point of the object being aligned is aligned with the "hanging" baseline of the parent text content element.
	//
	// Português:
	//
	//  O ponto de alinhamento do objeto que está sendo alinhado é alinhado com a linha de base "suspensa" do elemento de conteúdo de texto pai.
	KSvgAlignmentBaselineHanging SvgAlignmentBaseline = "hanging"

	// KSvgAlignmentBaselineMathematical
	//
	// English:
	//
	//  Matches the box's mathematical baseline to that of its parent.
	//
	// Português:
	//
	//  Corresponde a linha de base matemática da caixa à de seu pai.
	KSvgAlignmentBaselineMathematical SvgAlignmentBaseline = "mathematical"

	// KSvgAlignmentBaselineTop
	//
	// English:
	//
	//  Aligns the top of the aligned subtree with the top of the line box.
	//
	// Português:
	//
	//  Alinha o topo da subárvore alinhada com o topo da caixa de linha.
	KSvgAlignmentBaselineTop SvgAlignmentBaseline = "top"

	// KSvgAlignmentBaselineCenter
	//
	// English:
	//
	//  Aligns the center of the aligned subtree with the center of the line box.
	//
	// Português:
	//
	//  Alinha o centro da subárvore alinhada com o centro da caixa de linha.
	KSvgAlignmentBaselineCenter SvgAlignmentBaseline = "center"

	// KSvgAlignmentBaselineBottom
	//
	// English:
	//
	//  Aligns the bottom of the aligned subtree with the bottom of the line box.
	//
	// Português:
	//
	//  Alinha a parte inferior da subárvore alinhada com a parte inferior da caixa de linha.
	KSvgAlignmentBaselineBottom SvgAlignmentBaseline = "bottom"
)

func (SvgAlignmentBaseline) String 

func (e SvgAlignmentBaseline) String() string

type SvgAnimationRestart 

type SvgAnimationRestart string
const (
	// KSvgAnimationRestartAlways
	//
	// English:
	//
	//  This value indicates that the animation can be restarted at any time.
	//
	// Português:
	//
	//  Este valor indica que a animação pode ser reiniciada a qualquer momento.
	KSvgAnimationRestartAlways SvgAnimationRestart = "always"

	// KSvgAnimationRestartWhenNotActive
	//
	// English:
	//
	//  This value indicates that the animation can only be restarted when it is not active (i.e. after the active end).
	//
	// Attempts to restart the animation during its active duration are ignored.
	//
	// Português:
	//
	//  Este valor indica que a animação só pode ser reiniciada quando não estiver ativa (ou seja, após o término ativo).
	//
	// As tentativas de reiniciar a animação durante sua duração ativa são ignoradas.
	KSvgAnimationRestartWhenNotActive SvgAnimationRestart = "whenNotActive"

	// KSvgAnimationRestartNever
	//
	// English:
	//
	//  This value indicates that the animation cannot be restarted for the time the document is loaded.
	//
	// Português:
	//
	//  Esse valor indica que a animação não pode ser reiniciada durante o carregamento do documento.
	KSvgAnimationRestartNever SvgAnimationRestart = "never"
)

func (SvgAnimationRestart) String 

func (e SvgAnimationRestart) String() string

type SvgBaselineShift 

type SvgBaselineShift string
const (
	KSvgBaselineShiftAuto     SvgBaselineShift = "auto"
	KSvgBaselineShiftBaseline SvgBaselineShift = "baseline"
	KSvgBaselineShiftSuper    SvgBaselineShift = "super"
	KSvgBaselineShiftSub      SvgBaselineShift = "sub"
	KSvgBaselineShiftInherit  SvgBaselineShift = "inherit"
)

func (SvgBaselineShift) String 

func (e SvgBaselineShift) String() string

type SvgCalcMode 

type SvgCalcMode string
const (
	// KSvgCalcModeDiscrete
	//
	// English:
	//
	//  This specifies that the animation function will jump from one value to the next without any interpolation.
	//
	// Português:
	//
	//  Isso especifica que a função de animação saltará de um valor para o próximo sem qualquer interpolação.
	KSvgCalcModeDiscrete SvgCalcMode = "discrete"

	// KSvgCalcModeLinear
	//
	// English:
	//
	//  Simple linear interpolation between values is used to calculate the animation function. Except for
	//  <animateMotion>, this is the default value.
	//
	// Português:
	//
	//  A interpolação linear simples entre valores é usada para calcular a função de animação. Exceto para
	//  <animateMotion>, este é o valor padrão.
	KSvgCalcModeLinear SvgCalcMode = "linear"

	// KSvgCalcModePaced
	//
	// English:
	//
	//  Defines interpolation to produce an even pace of change across the animation.
	//
	// This is only supported for values that define a linear numeric range, and for which some notion of "distance"
	// between points can be calculated (e.g. position, width, height, etc.).
	// If paced is specified, any keyTimes or keySplines will be ignored.
	//
	// Português:
	//
	//  Define a interpolação para produzir um ritmo uniforme de mudança na animação.
	//
	// Ele é suportado apenas para valores que definem um intervalo numérico linear e para os quais alguma noção de
	// "distância" entre pontos pode ser calculada (por exemplo, posição, largura, altura etc.).
	// Se paced for especificado, quaisquer keyTimes ou keySplines serão ignorados.
	KSvgCalcModePaced SvgCalcMode = "paced"

	// KSvgCalcModeSpline
	//
	// English:
	//
	//  Interpolates from one value in the values list to the next according to a time function defined by a cubic Bézier
	//  spline. The points of the spline are defined in the keyTimes attribute, and the control points for each interval
	//  are defined in the keySplines attribute.
	//
	// Português:
	//
	//  Interpola de um valor na lista de valores para o próximo de acordo com uma função de tempo definida por uma spline
	//  de Bézier cúbica. Os pontos do spline são definidos no atributo keyTimes e os pontos de controle para cada
	//  intervalo são definidos no atributo keySplines.
	KSvgCalcModeSpline SvgCalcMode = "spline"
)

func (SvgCalcMode) String 

func (e SvgCalcMode) String() string

type SvgChannelSelector 

type SvgChannelSelector string
const (
	// KSvgChannelSelectorR
	//
	// English:
	//
	// This keyword specifies that the red color channel of the input image defined in in2 will be used to displace the
	// pixels of the input image defined in in along the x-axis.
	//
	// Português:
	//
	// Esta palavra-chave especifica que o canal de cor vermelha da imagem de entrada definida em in2 será usado para
	// deslocar os pixels da imagem de entrada definida em ao longo do eixo x.
	KSvgChannelSelectorR SvgChannelSelector = "R"

	// KSvgChannelSelectorG
	//
	// English:
	//
	// This keyword specifies that the green color channel of the input image defined in in2 will be used to displace the
	// pixels of the input image defined in in along the x-axis.
	//
	// Português:
	//
	// Esta palavra-chave especifica que o canal de cor verde da imagem de entrada definida em in2 será usado para
	// deslocar os pixels da imagem de entrada definida em ao longo do eixo x.
	KSvgChannelSelectorG SvgChannelSelector = "G"

	// KSvgChannelSelectorB
	//
	// English:
	//
	// This keyword specifies that the blue color channel of the input image defined in in2 will be used to displace the
	// pixels of the input image defined in in along the x-axis.
	//
	// Português:
	//
	// Essa palavra-chave especifica que o canal de cor azul da imagem de entrada definida em in2 será usado para deslocar
	// os pixels da imagem de entrada definida em ao longo do eixo x.
	KSvgChannelSelectorB SvgChannelSelector = "B"

	// KSvgChannelSelectorA
	//
	// English:
	//
	// This keyword specifies that the alpha channel of the input image defined in in2 will be used to displace the pixels
	// of the input image defined in in along the x-axis.
	//
	// Português:
	//
	// Essa palavra-chave especifica que o canal alfa da imagem de entrada definida em in2 será usado para deslocar os
	// pixels da imagem de entrada definida em ao longo do eixo x.
	KSvgChannelSelectorA SvgChannelSelector = "A"
)

func (SvgChannelSelector) String 

func (e SvgChannelSelector) String() string

type SvgClipPathUnits 

type SvgClipPathUnits string
const (
	// KSvgClipPathUnitsUserSpaceOnUse
	//
	// English:
	//
	//  This value indicates that all coordinates inside the <clipPath> element refer to the user coordinate system as
	//  defined when the clipping path was created.
	//
	// Português:
	//
	//  Este valor indica que todas as coordenadas dentro do elemento <clipPath> referem-se ao sistema de coordenadas do
	//  usuário conforme definido quando o caminho de recorte foi criado.
	KSvgClipPathUnitsUserSpaceOnUse SvgClipPathUnits = "userSpaceOnUse"

	// KSvgClipPathUnitsObjectBoundingBox
	//
	// English:
	//
	//  This value indicates that all coordinates inside the <clipPath> element are relative to the bounding box of the
	//  element the clipping path is applied to. It means that the origin of the coordinate system is the top left corner
	//  of the object bounding box and the width and height of the object bounding box are considered to have a length of
	//  1 unit value.
	//
	// Português:
	//
	//  Esse valor indica que todas as coordenadas dentro do elemento <clipPath> são relativas à caixa delimitadora do
	//  elemento ao qual o caminho de recorte é aplicado. Isso significa que a origem do sistema de coordenadas é o canto
	//  superior esquerdo da caixa delimitadora do objeto e a largura e a altura da caixa delimitadora do objeto são
	//  consideradas como tendo um comprimento de 1 valor unitário.
	KSvgClipPathUnitsObjectBoundingBox SvgClipPathUnits = "objectBoundingBox"
)

func (SvgClipPathUnits) String 

func (e SvgClipPathUnits) String() string

type SvgClipRule 

type SvgClipRule string
const (
	// KSvgClipRuleNonzero
	//
	// English:
	//
	//  The value nonzero determines the "insideness" of a point in the shape by drawing a ray from that point to infinity
	//  in any direction, and then examining the places where a segment of the shape crosses the ray. Starting with a
	//  count of zero, add one each time a path segment crosses the ray from left to right and subtract one each time a
	//  path segment crosses the ray from right to left. After counting the crossings, if the result is zero then the
	//  point is outside the path. Otherwise, it is inside.
	//
	// Português:
	//
	//  O valor diferente de zero determina a "interioridade" de um ponto na forma desenhando um raio desse ponto até o
	//  infinito em qualquer direção e, em seguida, examinando os locais onde um segmento da forma cruza o raio. Começando
	//  com uma contagem de zero, adicione um cada vez que um segmento de caminho cruza o raio da esquerda para a direita
	//  e subtraia um cada vez que um segmento de caminho cruza o raio da direita para a esquerda. Depois de contar os
	//  cruzamentos, se o resultado for zero, então o ponto está fora do caminho. Caso contrário, está dentro.
	KSvgClipRuleNonzero SvgClipRule = "nonzero"

	// KSvgClipRuleEvenOdd
	//
	// English:
	//
	//  The value evenodd determines the "insideness" of a point in the shape by drawing a ray from that point to
	//  infinity in any direction and counting the number of path segments from the given shape that the ray crosses. If
	//  this number is odd, the point is inside; if even, the point is outside.
	//
	// Português:
	//
	//  O valor evenodd determina a "interioridade" de um ponto na forma desenhando um raio desse ponto até o infinito em
	//  qualquer direção e contando o número de segmentos de caminho da forma dada que o raio cruza. Se este número for
	//  ímpar, o ponto está dentro; se par, o ponto está fora.
	KSvgClipRuleEvenOdd SvgClipRule = "evenodd"
)

func (SvgClipRule) String 

func (e SvgClipRule) String() string

type SvgCrossOrigin 

type SvgCrossOrigin string
const (
	// KSvgCrossOriginAnonymous
	//
	// English:
	//
	//  CORS requests for this element will have the credentials flag set to 'same-origin'.
	//
	// Português:
	//
	//  As solicitações CORS para este elemento terão o sinalizador de credenciais definido como 'mesma origem'.
	KSvgCrossOriginAnonymous SvgCrossOrigin = "anonymous"

	// KSvgCrossOriginUseCredentials
	//
	// English:
	//
	//  CORS requests for this element will have the credentials flag set to 'include'.
	//
	// Português:
	//
	//  As solicitações CORS para este elemento terão o sinalizador de credenciais definido como 'incluir'.
	KSvgCrossOriginUseCredentials SvgCrossOrigin = "use-credentials"
)

func (SvgCrossOrigin) String 

func (e SvgCrossOrigin) String() string

type SvgCursor 

type SvgCursor string
const (
	KSvgCursorAuto      SvgCursor = "auto"
	KSvgCursorCrossHair SvgCursor = "crosshair"
	KSvgCursorDefault   SvgCursor = "default"
	KSvgCursorPointer   SvgCursor = "pointer"
	KSvgCursorMove      SvgCursor = "move"
	KSvgCursorEResize   SvgCursor = " e-resize"
	KSvgCursorNeResize  SvgCursor = "ne-resize"
	KSvgCursorNwResize  SvgCursor = "nw-resize"
	KSvgCursorNResize   SvgCursor = "n-resize"
	KSvgCursorSeResize  SvgCursor = "se-resize"
	KSvgCursorSwResize  SvgCursor = "sw-resize"
	KSvgCursorSResize   SvgCursor = "s-resize"
	KSvgCursorWResize   SvgCursor = "w-resize"
	KSvgCursorText      SvgCursor = "text"
	KSvgCursorWait      SvgCursor = "wait"
	KSvgCursorHelp      SvgCursor = "help"
)

func (SvgCursor) String 

func (e SvgCursor) String() string

type SvgDirection 

type SvgDirection string
const (
	// KSvgDirectionLtr
	//
	// English:
	//
	//  Default. Left-to-right text direction.
	//
	// Português:
	//
	//  Padrão. Direção do texto da esquerda para a direita.
	KSvgDirectionLtr SvgDirection = "ltr"

	// KSvgDirectionRtl
	//
	// English:
	//
	//  Right-to-left text direction.
	//
	// Português:
	//
	//  Direção do texto da direita para a esquerda.
	KSvgDirectionRtl SvgDirection = "rtl"
)

func (SvgDirection) String 

func (e SvgDirection) String() string

type SvgDisplay 

type SvgDisplay string
const (
	KSvgDisplayBlock             SvgDisplay = "block"
	KSvgDisplayInline            SvgDisplay = "inline"
	KSvgDisplayRunIn             SvgDisplay = "run-in"
	KSvgDisplayFlow              SvgDisplay = "flow"
	KSvgDisplayFlowRoot          SvgDisplay = "flow-root"
	KSvgDisplayTable             SvgDisplay = "table"
	KSvgDisplayFlex              SvgDisplay = "flex"
	KSvgDisplayGrid              SvgDisplay = "grid"
	KSvgDisplayRuby              SvgDisplay = "ruby"
	KSvgDisplayListItem          SvgDisplay = "list-item"
	KSvgDisplayTableRowGroup     SvgDisplay = "table-row-group"
	KSvgDisplayTableHeaderGroup  SvgDisplay = "table-header-group"
	KSvgDisplayTableFooterGroup  SvgDisplay = "table-footer-group"
	KSvgDisplayTableRow          SvgDisplay = "table-row"
	KSvgDisplayTableCell         SvgDisplay = "table-cell"
	KSvgDisplayTableColumnGroup  SvgDisplay = "table-column-group"
	KSvgDisplayTableColumn       SvgDisplay = "table-column"
	KSvgDisplayTableCaption      SvgDisplay = "table-caption"
	KSvgDisplayRubyBase          SvgDisplay = "ruby-base"
	KSvgDisplayRubyText          SvgDisplay = "ruby-text"
	KSvgDisplayRubyBaseContainer SvgDisplay = "ruby-base-container"
	KSvgDisplayRubyTextContainer SvgDisplay = "ruby-text-container"
	KSvgDisplayContents          SvgDisplay = "contents"
	KSvgDisplayNone              SvgDisplay = "none"
	KSvgDisplayInlineBlock       SvgDisplay = "inline-block"
	KSvgDisplayInlineListItem    SvgDisplay = "inline-list-item"
	KSvgDisplayInlineTable       SvgDisplay = "inline-table"
	KSvgDisplayInlineFlex        SvgDisplay = "inline-flex"
	KSvgDisplayInlineGrid        SvgDisplay = "inline-grid"
)

func (SvgDisplay) String 

func (e SvgDisplay) String() string

type SvgDominantBaseline 

type SvgDominantBaseline string
const (
	// KSvgDominantBaselineAuto
	//
	// English:
	//
	//  If this property occurs on a <text> element, then the computed value depends on the value of the writing-mode
	//  attribute.
	//
	// If the writing-mode is horizontal, then the value of the dominant-baseline component is alphabetic. Otherwise, if
	// the writing-mode is vertical, then the value of the dominant-baseline component is central.
	//
	// If this property occurs on a <tspan>, <tref>, <altGlyph>, or <textPath> element, then the dominant-baseline and
	// the baseline-table components remain the same as those of the parent text content element.
	//
	// If the computed baseline-shift value actually shifts the baseline, then the baseline-table font-size component is
	// set to the value of the font-size attribute on the element on which the dominant-baseline attribute occurs,
	// otherwise the baseline-table font-size remains the same as that of the element.
	//
	// If there is no parent text content element, the scaled-baseline-table value is constructed as above for <text>
	// elements.
	//
	// Português:
	//
	// Se esta propriedade ocorrer em um elemento <text>, então o valor calculado depende do valor do atributo write-mode.
	//
	// Se o modo de escrita for horizontal, então o valor do componente da linha de base dominante será alfabético.
	// Caso contrário, se o modo de escrita for vertical, então o valor do componente da linha de base dominante
	// é central.
	//
	// Se essa propriedade ocorrer em um elemento <tspan>, <tref>, <altGlyph> ou <textPath>, os componentes de linha de
	// base dominante e tabela de linha de base permanecerão iguais aos do elemento de conteúdo de texto pai.
	//
	// Se o valor calculado de mudança de linha de base realmente mudar a linha de base, o componente tamanho da fonte
	// da tabela de linha de base será definido como o valor do atributo tamanho da fonte no elemento no qual o atributo
	// da linha de base dominante ocorre, caso contrário, a fonte da tabela de linha de base -size permanece igual ao
	// do elemento.
	//
	// Se não houver nenhum elemento de conteúdo de texto pai, o valor scaled-baseline-table será construído como acima
	// para elementos <text>.
	KSvgDominantBaselineAuto SvgDominantBaseline = "auto"

	// KSvgDominantBaselineIdeographic
	//
	// English:
	//
	//  The baseline-identifier for the dominant-baseline is set to be ideographic, the derived baseline-table is
	//  constructed using the ideographic baseline-table in the font, and the baseline-table font-size is changed to the
	//  value of the font-size attribute on this element.
	//
	// Portuguese
	//
	//  O identificador de linha de base para a linha de base dominante é definido como ideográfico, a tabela de linha de
	//  base derivada é construída usando a tabela de linha de base ideográfica na fonte e o tamanho da fonte da tabela
	//  de linha de base é alterado para o valor do tamanho da fonte atributo neste elemento.
	KSvgDominantBaselineIdeographic SvgDominantBaseline = "ideographic"

	// KSvgDominantBaselineAlphabetic
	//
	// English:
	//
	//  The baseline-identifier for the dominant-baseline is set to be alphabetic, the derived baseline-table is
	//  constructed using the alphabetic baseline-table in the font, and the baseline-table font-size is changed to the
	//  value of the font-size attribute on this element.
	//
	// Portuguese
	//
	//  O identificador de linha de base para a linha de base dominante é definido como alfabético, a tabela de linha de
	//  base derivada é construída usando a tabela de linha de base alfabética na fonte e o tamanho da fonte da tabela de
	//  linha de base é alterado para o valor do tamanho da fonte atributo neste elemento.
	KSvgDominantBaselineAlphabetic SvgDominantBaseline = "alphabetic"

	// KSvgDominantBaselineHanging
	//
	// English:
	//
	//  The baseline-identifier for the dominant-baseline is set to be hanging, the derived baseline-table is constructed
	//  using the hanging baseline-table in the font, and the baseline-table font-size is changed to the value of the
	//  font-size attribute on this element.
	//
	// Portuguese
	//
	//  O identificador de linha de base para a linha de base dominante é definido como suspenso, a tabela de linha de
	//  base derivada é construída usando a tabela de linha de base suspensa na fonte e o tamanho da fonte da tabela de
	//  linha de base é alterado para o valor do tamanho da fonte atributo neste elemento.
	KSvgDominantBaselineHanging SvgDominantBaseline = "hanging"

	// KSvgDominantBaselineMathematical
	//
	// English:
	//
	//  The baseline-identifier for the dominant-baseline is set to be mathematical, the derived baseline-table is
	//  constructed using the mathematical baseline-table in the font, and the baseline-table font-size is changed to the
	//  value of the font-size attribute on this element.
	//
	// Portuguese
	//
	//  The baseline-identifier for the dominant-baseline is set to be mathematical, the derived baseline-table is
	//  constructed using the mathematical baseline-table in the font, and the baseline-table font-size is changed to the
	//  value of the font-size attribute on this element.
	KSvgDominantBaselineMathematical SvgDominantBaseline = "mathematical"

	// KSvgDominantBaselineCentral
	//
	// English:
	//
	//  The baseline-identifier for the dominant-baseline is set to be central. The derived baseline-table is constructed
	//  from the defined baselines in a baseline-table in the font. That font baseline-table is chosen using the following
	//  priority order of baseline-table names: ideographic, alphabetic, hanging, mathematical. The baseline-table
	//  font-size is changed to the value of the font-size attribute on this element.
	//
	// Portuguese
	//
	//  O identificador de linha de base para a linha de base dominante é definido como central. A tabela de linha de base
	//  derivada é construída a partir das linhas de base definidas em uma tabela de linha de base na fonte. Essa tabela
	//  de linha de base de fonte é escolhida usando a seguinte ordem de prioridade de nomes de tabela de linha de base:
	//  ideográfica, alfabética, suspensa, matemática. O font-size da baseline-table é alterado para o valor do atributo
	//  font-size neste elemento.
	KSvgDominantBaselineCentral SvgDominantBaseline = "central"

	// KSvgDominantBaselineMiddle
	//
	// English:
	//
	//  The baseline-identifier for the dominant-baseline is set to be middle. The derived baseline-table is constructed
	//  from the defined baselines in a baseline-table in the font. That font baseline-table is chosen using the following
	//  priority order of baseline-table names: alphabetic, ideographic, hanging, mathematical. The baseline-table
	//  font-size is changed to the value of the font-size attribute on this element.
	//
	// Portuguese
	//
	//  O identificador de linha de base para a linha de base dominante é definido como meio. A tabela de linha de base
	//  derivada é construída a partir das linhas de base definidas em uma tabela de linha de base na fonte. Essa tabela
	//  de linha de base de fonte é escolhida usando a seguinte ordem de prioridade de nomes de tabela de linha de base:
	//  alfabética, ideográfica, suspensa, matemática. O font-size da baseline-table é alterado para o valor do atributo
	//  font-size neste elemento.
	KSvgDominantBaselineMiddle SvgDominantBaseline = "middle"

	// KSvgDominantBaselineTextAfterEdge
	//
	// English:
	//
	//  The baseline-identifier for the dominant-baseline is set to be text-after-edge. The derived baseline-table is
	//  constructed from the defined baselines in a baseline-table in the font. The choice of which font baseline-table
	//  to use from the baseline-tables in the font is browser dependent. The baseline-table font-size is changed to the
	//  value of the font-size attribute on this element.
	//
	// Portuguese
	//
	//  O identificador de linha de base para a linha de base dominante é definido como texto após borda. A tabela de
	//  linha de base derivada é construída a partir das linhas de base definidas em uma tabela de linha de base na fonte.
	//  A escolha de qual tabela de linha de base de fonte usar a partir das tabelas de linha de base na fonte depende do
	//  navegador. O font-size da baseline-table é alterado para o valor do atributo font-size neste elemento.
	KSvgDominantBaselineTextAfterEdge SvgDominantBaseline = "text-after-edge"

	// KSvgDominantBaselineTextBeforeEdge
	//
	// English:
	//
	//  The baseline-identifier for the dominant-baseline is set to be text-before-edge. The derived baseline-table is
	//  constructed from the defined baselines in a baseline-table in the font. The choice of which baseline-table to use
	//  from the baseline-tables in the font is browser dependent. The baseline-table font-size is changed to the value of
	//  the font-size attribute on this element.
	//
	// Portuguese
	//
	//  O identificador de linha de base para a linha de base dominante é definido como text-before-edge. A tabela de
	//  linha de base derivada é construída a partir das linhas de base definidas em uma tabela de linha de base na fonte.
	//  A escolha de qual tabela de linha de base usar a partir das tabelas de linha de base na fonte depende do
	//  navegador. O font-size da baseline-table é alterado para o valor do atributo font-size neste elemento.
	KSvgDominantBaselineTextBeforeEdge SvgDominantBaseline = "text-before-edge"

	// KSvgDominantBaselineTextTop
	//
	// English:
	//
	//  This value uses the top of the em box as the baseline.
	//
	// Portuguese
	//
	//  Esse valor usa a parte superior da caixa em como linha de base.
	KSvgDominantBaselineTextTop SvgDominantBaseline = "text-top"
)

func (SvgDominantBaseline) String 

func (e SvgDominantBaseline) String() string

type SvgDur 

type SvgDur string
const (

	// KSvgDurMedia
	//
	// English:
	//
	//  This value specifies the simple duration as the intrinsic media duration. This is only valid for elements that
	//  define media. (For animation elements the attribute will be ignored if media is specified.)
	//
	// Portuguese
	//
	//  Esse valor especifica a duração simples como a duração da mídia intrínseca. Isso só é válido para elementos que
	//  definem mídia. (Para elementos de animação, o atributo será ignorado se a mídia for especificada.)
	KSvgDurMedia SvgDur = "media"

	// KSvgDurIndefinite
	//
	// English:
	//
	//  This value specifies the simple duration as indefinite.
	//
	// Portuguese
	//
	//  Este valor especifica a duração simples como indefinida.
	//
	KSvgDurIndefinite SvgDur = "indefinite"
)

func (SvgDur) String 

func (e SvgDur) String() string

type SvgEdgeMode 

type SvgEdgeMode string
const (

	// KSvgEdgeModeDuplicate
	//
	// English:
	//
	//  This value indicates that the input image is extended along each of its borders as necessary by duplicating the
	//  color values at the given edge of the input image.
	//
	// Portuguese
	//
	//  Esse valor indica que a imagem de entrada é estendida ao longo de cada uma de suas bordas conforme necessário,
	//  duplicando os valores de cor na borda especificada da imagem de entrada.
	KSvgEdgeModeDuplicate SvgEdgeMode = "duplicate"

	// KSvgEdgeModeWrap
	//
	// English:
	//
	//  This value indicates that the input image is extended by taking the color values from the opposite edge of the
	//  image.
	//
	// Portuguese
	//
	//  Este valor indica que a imagem de entrada é estendida tomando os valores de cor da borda oposta da imagem.
	KSvgEdgeModeWrap SvgEdgeMode = "wrap"

	// KSvgEdgeModeNone
	//
	// English:
	//
	//  This value indicates that the input image is extended with pixel values of zero for R, G, B and A.
	//
	// Portuguese
	//
	//  Este valor indica que a imagem de entrada é estendida com valores de pixel de zero para R, G, B e A.
	KSvgEdgeModeNone SvgEdgeMode = "none"
)

func (SvgEdgeMode) String 

func (e SvgEdgeMode) String() string

type SvgFillRule 

type SvgFillRule string
const (

	// KSvgFillRuleNonzero
	//
	// English:
	//
	//  The value nonzero determines the "insideness" of a point in the shape by drawing a ray from that point to infinity
	//  in any direction, and then examining the places where a segment of the shape crosses the ray. Starting with a
	//  count of zero, add one each time a path segment crosses the ray from left to right and subtract one each time a
	//  path segment crosses the ray from right to left. After counting the crossings, if the result is zero then the
	//  point is outside the path. Otherwise, it is inside.
	//
	// Portuguese
	//
	//  O valor diferente de zero determina a "interioridade" de um ponto na forma desenhando um raio desse ponto até o
	//  infinito em qualquer direção e, em seguida, examinando os locais onde um segmento da forma cruza o raio. Começando
	//  com uma contagem de zero, adicione um cada vez que um segmento de caminho cruza o raio da esquerda para a direita
	//  e subtraia um cada vez que um segmento de caminho cruza o raio da direita para a esquerda. Depois de contar os
	//  cruzamentos, se o resultado for zero, então o ponto está fora do caminho. Caso contrário, está dentro.
	KSvgFillRuleNonzero SvgFillRule = "nonzero"

	// KSvgFillRuleEvenOdd
	//
	// English:
	//
	//  The value evenodd determines the "insideness" of a point in the shape by drawing a ray from that point to infinity
	//  in any direction and counting the number of path segments from the given shape that the ray crosses. If this
	//  number is odd, the point is inside; if even, the point is outside.
	//
	// Portuguese
	//
	//  O valor evenodd determina a "interioridade" de um ponto na forma desenhando um raio desse ponto até o infinito em
	//  qualquer direção e contando o número de segmentos de caminho da forma dada que o raio cruza. Se este número
	//  for ímpar, o ponto está dentro; se par, o ponto está fora.
	KSvgFillRuleEvenOdd SvgFillRule = "evenodd"
)

func (SvgFillRule) String 

func (e SvgFillRule) String() string

type SvgFilterUnits 

type SvgFilterUnits string
const (

	// KSvgFilterUnitsUserSpaceOnUse
	//
	// English:
	//
	//  x, y, width and height represent values in the current coordinate system that results from taking the current user
	//  coordinate system in place at the time when the <filter> element is referenced (i.e., the user coordinate system
	//  for the element referencing the <filter> element via a filter attribute).
	//
	// Portuguese
	//
	//  x, y, largura e altura representam valores no sistema de coordenadas atual que resulta da tomada do sistema de
	//  coordenadas do usuário atual no momento em que o elemento <filter> é referenciado (ou seja, o sistema de
	//  coordenadas do usuário para o elemento que faz referência ao <filter > elemento através de um atributo de filtro).
	KSvgFilterUnitsUserSpaceOnUse SvgFilterUnits = "userSpaceOnUse"

	// KSvgFilterUnitsObjectBoundingBox
	//
	// English:
	//
	//  In that case, x, y, width and height represent fractions or percentages of the bounding box on the referencing
	//  element.
	//
	// Portuguese
	//
	//  Nesse caso, x, y, largura e altura representam frações ou porcentagens da caixa delimitadora no elemento de
	//  referência.
	KSvgFilterUnitsObjectBoundingBox SvgFilterUnits = "objectBoundingBox"
)

func (SvgFilterUnits) String 

func (e SvgFilterUnits) String() string

type SvgFontStretch 

type SvgFontStretch string
const (
	KSvgFontStretchNormal         SvgFontStretch = "normal"
	KSvgFontStretchUltraCondensed SvgFontStretch = "ultra-condensed"
	KSvgFontStretchExtraCondensed SvgFontStretch = "extra-condensed"
	KSvgFontStretchCondensed      SvgFontStretch = "condensed"
	KSvgFontStretchSemiCondensed  SvgFontStretch = "semi-condensed"
	KSvgFontStretchSemiExpanded   SvgFontStretch = "semi-expanded"
	KSvgFontStretchExpanded       SvgFontStretch = "expanded"
	KSvgFontStretchExtraExpanded  SvgFontStretch = "extra-expanded"
	KSvgFontStretchUltraExpanded  SvgFontStretch = "ultra-expanded"
)

func (SvgFontStretch) String 

func (e SvgFontStretch) String() string

type SvgGradientUnits 

type SvgGradientUnits string
const (

	// KSvgGradientUnitsUserSpaceOnUse
	//
	// English:
	//
	//  This value indicates that the attributes represent values in the coordinate system that results from taking the
	//  current user coordinate system in place at the time when the gradient element is referenced (i.e., the user
	//  coordinate system for the element referencing the gradient element via a fill or stroke property) and then
	//  applying the transform specified by attribute gradientTransform. Percentages represent values relative to the
	//  current SVG viewport.
	//
	// Portuguese
	//
	//  Este valor indica que os atributos representam valores no sistema de coordenadas que resulta da tomada do sistema
	//  de coordenadas do usuário atual no momento em que o elemento gradiente é referenciado (ou seja, o sistema de
	//  coordenadas do usuário para o elemento referenciando o elemento gradiente por meio de um preenchimento ou stroke
	//  property) e, em seguida, aplicar a transformação especificada pelo atributo gradientTransform.
	//  As porcentagens representam valores relativos à janela de visualização SVG atual.
	KSvgGradientUnitsUserSpaceOnUse SvgGradientUnits = "userSpaceOnUse"

	// KSvgGradientUnitsObjectBoundingBox
	//
	// English:
	//
	//  This value indicates that the user coordinate system for the attributes is established using the bounding box of
	//  the element to which the gradient is applied and then applying the transform specified by attribute
	//  gradientTransform.
	//
	// Percentages represent values relative to the bounding box for the object.
	//
	// With this value and gradientTransform being the identity matrix, the normal of the linear gradient is
	// perpendicular to the gradient vector in object bounding box space (i.e., the abstract coordinate system where
	// (0,0) is at the top/left of the object bounding box and (1,1) is at the bottom/right of the object bounding box).
	// When the object's bounding box is not square, the gradient normal which is initially perpendicular to the gradient
	// vector within object bounding box space may render non-perpendicular relative to the gradient vector in user space.
	// If the gradient vector is parallel to one of the axes of the bounding box, the gradient normal will remain
	// perpendicular.
	// This transformation is due to application of the non-uniform scaling transformation from bounding box space to
	// user space.
	//
	// Portuguese
	//
	//  Esse valor indica que o sistema de coordenadas do usuário para os atributos é estabelecido usando a caixa
	//  delimitadora do elemento ao qual o gradiente é aplicado e, em seguida, aplicando a transformação especificada
	//  pelo atributo gradientTransform.
	//
	// As porcentagens representam valores relativos à caixa delimitadora do objeto.
	//
	// Com este valor e gradientTransform sendo a matriz identidade, a normal do gradiente linear é perpendicular ao
	// vetor gradiente no espaço da caixa delimitadora do objeto (ou seja, o sistema de coordenadas abstrato onde (0,0)
	// está no canto superior esquerdo da caixa delimitadora do objeto e (1,1) está na parte inferior direita da caixa
	// delimitadora do objeto). Quando a caixa delimitadora do objeto não é quadrada, o gradiente normal que é
	// inicialmente perpendicular ao vetor gradiente dentro do espaço da caixa delimitadora do objeto pode tornar-se não
	// perpendicular em relação ao vetor gradiente no espaço do usuário. Se o vetor gradiente for paralelo a um dos eixos
	// da caixa delimitadora, a normal do gradiente permanecerá perpendicular. Essa transformação se deve à aplicação da
	// transformação de dimensionamento não uniforme do espaço da caixa delimitadora para o espaço do usuário.
	KSvgGradientUnitsObjectBoundingBox SvgGradientUnits = "objectBoundingBox"
)

func (SvgGradientUnits) String 

func (e SvgGradientUnits) String() string

type SvgIn 

type SvgIn string
const (

	// KSvgInSourceGraphic
	//
	// English:
	//
	//  This keyword represents the graphics elements that were the original input into the <filter> element.
	//
	// Portuguese
	//
	//  Esta palavra-chave representa os elementos gráficos que foram a entrada original no elemento <filter>.
	KSvgInSourceGraphic SvgIn = "SourceGraphic"

	// KSvgInSourceAlpha
	//
	// English:
	//
	//  This keyword represents the graphics elements that were the original input into the <filter> element.
	//  SourceAlpha has all of the same rules as SourceGraphic except that only the alpha channel is used.
	//
	// Portuguese
	//
	//  Esta palavra-chave representa os elementos gráficos que foram a entrada original no elemento <filter>.
	//  SourceAlpha tem todas as mesmas regras que SourceGraphic, exceto que apenas o canal alfa é usado.
	KSvgInSourceAlpha SvgIn = "SourceAlpha"

	// KSvgInBackgroundImage
	//
	// English:
	//
	//  This keyword represents an image snapshot of the SVG document under the filter region at the time that the
	//  <filter> element was invoked.
	//
	// Portuguese
	//
	//  Essa palavra-chave representa um instantâneo de imagem do documento SVG na região do filtro no momento em que o
	//  elemento <filter> foi invocado.
	KSvgInBackgroundImage SvgIn = "BackgroundImage"

	// KSvgInBackgroundAlpha
	//
	// English:
	//
	//  Same as BackgroundImage except only the alpha channel is used.
	//
	// Portuguese
	//
	//  O mesmo que BackgroundImage, exceto que apenas o canal alfa é usado.
	KSvgInBackgroundAlpha SvgIn = "BackgroundAlpha"

	// KSvgInFillPaint
	//
	// English:
	//
	//  This keyword represents the value of the fill property on the target element for the filter effect.
	//
	// In many cases, the FillPaint is opaque everywhere, but that might not be the case if a shape is painted with a
	// gradient or pattern which itself includes transparent or semi-transparent parts.
	//
	// Portuguese
	//
	//  Essa palavra-chave representa o valor da propriedade fill no elemento de destino para o efeito de filtro.
	//
	// Em muitos casos, o FillPaint é opaco em todos os lugares, mas esse pode não ser o caso se uma forma for pintada
	// com um gradiente ou padrão que inclui partes transparentes ou semitransparentes.
	KSvgInFillPaint SvgIn = "FillPaint"

	// KSvgInStrokePaint
	//
	// English:
	//
	//  This keyword represents the value of the stroke property on the target element for the filter effect.
	//
	// In many cases, the StrokePaint is opaque everywhere, but that might not be the case if a shape is painted with a
	// gradient or pattern which itself includes transparent or semi-transparent parts.
	//
	// Portuguese
	//
	//  Essa palavra-chave representa o valor da propriedade stroke no elemento de destino para o efeito de filtro.
	//
	// Em muitos casos, o StrokePaint é opaco em todos os lugares, mas esse pode não ser o caso se uma forma for pintada
	// com um gradiente ou padrão que inclui partes transparentes ou semitransparentes.
	KSvgInStrokePaint SvgIn = "StrokePaint"
)

func (SvgIn) String 

func (e SvgIn) String() string

type SvgIn2 

type SvgIn2 string
const (
	KSvgIn2SourceGraphic   SvgIn2 = "SourceGraphic"
	KSvgIn2SourceAlpha     SvgIn2 = "SourceAlpha"
	KSvgIn2BackgroundImage SvgIn2 = "BackgroundImage"
	KSvgIn2BackgroundAlpha SvgIn2 = "BackgroundAlpha"
	KSvgIn2FillPaint       SvgIn2 = "FillPaint"
	KSvgIn2StrokePaint     SvgIn2 = "StrokePaint"
)

func (SvgIn2) String 

func (e SvgIn2) String() string

type SvgLengthAdjust 

type SvgLengthAdjust string
const (
	KSvgLengthAdjustSpacing          SvgLengthAdjust = "spacing"
	KSvgLengthAdjustSpacingAndGlyphs SvgLengthAdjust = "spacingAndGlyphs"
)

func (SvgLengthAdjust) String 

func (e SvgLengthAdjust) String() string

type SvgMarkerUnits 

type SvgMarkerUnits string
const (
	// KSvgMarkerUnitsUserSpaceOnUse
	//
	// English:
	//
	// This value specifies that the markerWidth and markerHeight attributes and the contents of the <marker> element
	// represent values in the current user coordinate system in place for the graphic object referencing the marker
	// (i.e., the user coordinate system for the element referencing the <marker> element via a marker, marker-start,
	// marker-mid, or marker-end property).
	//
	// Português:
	//
	// Este valor especifica que os atributos markerWidth e markerHeight e o conteúdo do elemento <marker> representam
	// valores no sistema de coordenadas do usuário atual em vigor para o objeto gráfico que faz referência ao marcador
	// (ou seja, o sistema de coordenadas do usuário para o elemento que faz referência ao <marker> elemento por meio de
	// um marcador, marcador inicial, marcador intermediário ou marcador final).
	KSvgMarkerUnitsUserSpaceOnUse SvgMarkerUnits = "userSpaceOnUse"

	// KSvgMarkerUnitsStrokeWidth
	//
	// English:
	//
	// This value specifies that the markerWidth and markerHeight attributes and the contents of the <marker> element
	// represent values in a coordinate system which has a single unit equal the size in user units of the current stroke
	// width (see the stroke-width attribute) in place for the graphic object referencing the marker.
	//
	// Português:
	//
	// Este valor especifica que os atributos markerWidth e markerHeight e o conteúdo do elemento <marker> representam
	// valores em um sistema de coordenadas que tem uma única unidade igual ao tamanho em unidades de usuário da largura
	// do traço atual (consulte o atributo stroke-width) no lugar para o objeto gráfico que faz referência ao marcador.
	KSvgMarkerUnitsStrokeWidth SvgMarkerUnits = "strokeWidth"
)

func (SvgMarkerUnits) String 

func (e SvgMarkerUnits) String() string

type SvgMode 

type SvgMode string

SvgMode

English:

For each pixel among the layers to which it is applied, a blend mode takes the colors of the foreground and the background, performs a calculation on them, and returns a new color value.

Changes between blend modes are not interpolated. Any change occurs immediately.

Português:

Para cada pixel entre as camadas às quais é aplicado, um modo de mesclagem pega as cores do primeiro plano e do plano de fundo, realiza um cálculo sobre elas e retorna um novo valor de cor.

As alterações entre os modos de mesclagem não são interpoladas. Qualquer mudança ocorre imediatamente. 

const (
	// KSvgModeNormal
	//
	// English:
	//
	// The final color is the top color, regardless of what the bottom color is. The effect is like two opaque pieces of
	// paper overlapping.
	//
	// Português:
	//
	// A cor final é a cor de cima, independentemente da cor de baixo. O efeito é como dois pedaços opacos de papel
	// sobrepostos.
	KSvgModeNormal SvgMode = "normal"

	// KSvgModeMultiply
	//
	// English:
	//
	// The final color is the result of multiplying the top and bottom colors. A black layer leads to a black final layer,
	// and a white layer leads to no change. The effect is like two images printed on transparent film overlapping.
	//
	// Português:
	//
	// A cor final é o resultado da multiplicação das cores superior e inferior. Uma camada preta leva a uma camada final
	// preta e uma camada branca não leva a nenhuma alteração. O efeito é como duas imagens impressas em filme
	// transparente sobrepostas.
	KSvgModeMultiply SvgMode = "multiply"

	// KSvgModeScreen
	//
	// English:
	//
	// The final color is the result of inverting the colors, multiplying them, and inverting that value. A black layer
	// leads to no change, and a white layer leads to a white final layer. The effect is like two images shone onto a
	// projection screen.
	//
	// Português:
	//
	// A cor final é o resultado de inverter as cores, multiplicá-las e inverter esse valor. Uma camada preta não leva a
	// nenhuma alteração e uma camada branca leva a uma camada final branca. O efeito é como duas imagens brilhando em uma
	// tela de projeção.
	KSvgModeScreen SvgMode = "screen"

	// KSvgModeOverlay
	//
	// English:
	//
	// The final color is the result of multiply if the bottom color is darker, or screen if the bottom color is lighter.
	// This blend mode is equivalent to hard-light but with the layers swapped.
	//
	// Português:
	//
	// A cor final é o resultado da multiplicação se a cor de baixo for mais escura, ou da tela se a cor de baixo for mais
	// clara. Este modo de mesclagem é equivalente à luz forte, mas com as camadas trocadas.
	KSvgModeOverlay SvgMode = "overlay"

	// KSvgModeDarken
	//
	// English:
	//
	// The final color is composed of the darkest values of each color channel.
	//
	// Português:
	//
	// A cor final é composta pelos valores mais escuros de cada canal de cor.
	KSvgModeDarken SvgMode = "darken"

	// KSvgModeLighten
	//
	// English:
	//
	// The final color is composed of the lightest values of each color channel.
	//
	// Português:
	//
	// A cor final é composta pelos valores mais claros de cada canal de cor.
	KSvgModeLighten SvgMode = "lighten"

	// KSvgModeColorDodge
	//
	// English:
	//
	// The final color is the result of dividing the bottom color by the inverse of the top color.
	// A black foreground leads to no change. A foreground with the inverse color of the backdrop leads to a fully lit
	// color. This blend mode is similar to screen, but the foreground need only be as light as the inverse of the
	// backdrop to create a fully lit color.
	//
	// Português:
	//
	// A cor final é o resultado da divisão da cor de baixo pelo inverso da cor de cima.
	// Um primeiro plano preto não leva a nenhuma mudança. Um primeiro plano com a cor inversa do pano de fundo leva a uma
	// cor totalmente iluminada. Esse modo de mesclagem é semelhante à tela, mas o primeiro plano precisa ser tão claro
	// quanto o inverso do plano de fundo para criar uma cor totalmente iluminada.
	KSvgModeColorDodge SvgMode = "color-dodge"

	// KSvgModeColorBurn
	//
	// English:
	//
	// The final color is the result of inverting the bottom color, dividing the value by the top color, and inverting
	// that value.
	// A white foreground leads to no change. A foreground with the inverse color of the backdrop leads to a black final
	// image. This blend mode is similar to multiply, but the foreground need only be as dark as the inverse of the
	// backdrop to make the final image black.
	//
	// Português:
	//
	// A cor final é o resultado da inversão da cor inferior, dividindo o valor pela cor superior e invertendo esse valor.
	// Um primeiro plano branco não leva a nenhuma mudança. Um primeiro plano com a cor inversa do pano de fundo leva a
	// uma imagem final preta. Esse modo de mesclagem é semelhante à multiplicação, mas o primeiro plano precisa ser tão
	// escuro quanto o inverso do pano de fundo para tornar a imagem final preta.
	KSvgModeColorBurn SvgMode = "color-burn"

	// KSvgModeHardLight
	//
	// English:
	//
	// The final color is the result of multiply if the top color is darker, or screen if the top color is lighter.
	// This blend mode is equivalent to overlay but with the layers swapped. The effect is similar to shining a harsh
	// spotlight on the backdrop.
	//
	// Português:
	//
	// A cor final é o resultado da multiplicação se a cor de cima for mais escura, ou da tela se a cor de cima for mais
	// clara.
	// Este modo de mesclagem é equivalente à sobreposição, mas com as camadas trocadas. O efeito é semelhante ao de um
	// holofote forte sobre o pano de fundo.
	KSvgModeHardLight SvgMode = "hard-light"

	// KSvgModeSoftLight
	//
	// English:
	//
	// The final color is similar to hard-light, but softer. This blend mode behaves similar to hard-light.
	// The effect is similar to shining a diffused spotlight on the backdrop*.*
	//
	// Português:
	//
	// A cor final é semelhante à luz dura, mas mais suave. Esse modo de mesclagem se comporta de maneira semelhante à
	// luz forte.
	// O efeito é semelhante ao de um holofote difuso no fundo.
	KSvgModeSoftLight SvgMode = "soft-light"

	// KSvgModeDifference
	//
	// English:
	//
	// The final color is the result of subtracting the darker of the two colors from the lighter one.
	// A black layer has no effect, while a white layer inverts the other layer's color.
	//
	// Português:
	//
	// A cor final é o resultado da subtração da mais escura das duas cores da mais clara.
	// Uma camada preta não tem efeito, enquanto uma camada branca inverte a cor da outra camada.
	KSvgModeDifference SvgMode = "difference"

	// KSvgModeExclusion
	//
	// English:
	//
	// The final color is similar to difference, but with less contrast.
	// As with difference, a black layer has no effect, while a white layer inverts the other layer's color.
	//
	// Português:
	//
	// A cor final é semelhante à diferença, mas com menos contraste.
	// Tal como acontece com a diferença, uma camada preta não tem efeito, enquanto uma camada branca inverte a cor da
	// outra camada.
	KSvgModeExclusion SvgMode = "exclusion"

	// KSvgModeHue
	//
	// English:
	//
	// The final color has the hue of the top color, while using the saturation and luminosity of the bottom color.
	//
	// Português:
	//
	// A cor final tem a tonalidade da cor de cima, enquanto usa a saturação e luminosidade da cor de baixo.
	KSvgModeHue SvgMode = "hue"

	// KSvgModeSaturation
	//
	// English:
	//
	// The final color has the saturation of the top color, while using the hue and luminosity of the bottom color.
	// A pure gray backdrop, having no saturation, will have no effect.
	//
	// Português:
	//
	// A cor final tem a saturação da cor de cima, enquanto usa a tonalidade e a luminosidade da cor de baixo.
	// Um pano de fundo cinza puro, sem saturação, não terá efeito.
	KSvgModeSaturation SvgMode = "saturation"

	// KSvgModeColor
	//
	// English:
	//
	// The final color has the hue and saturation of the top color, while using the luminosity of the bottom color.
	// The effect preserves gray levels and can be used to colorize the foreground.
	//
	// Português:
	//
	// A cor final tem o matiz e a saturação da cor de cima, enquanto usa a luminosidade da cor de baixo.
	// O efeito preserva os níveis de cinza e pode ser usado para colorir o primeiro plano.
	KSvgModeColor SvgMode = "color"

	// KSvgModeLuminosity
	//
	// English:
	//
	// The final color has the luminosity of the top color, while using the hue and saturation of the bottom color.
	// This blend mode is equivalent to color, but with the layers swapped.
	//
	// Português:
	//
	// A cor final tem a luminosidade da cor de cima, enquanto usa o matiz e a saturação da cor de baixo.
	// Este modo de mesclagem é equivalente à cor, mas com as camadas trocadas.
	KSvgModeLuminosity SvgMode = "luminosity"
)

func (SvgMode) String 

func (e SvgMode) String() string

type SvgOperatorFeComposite 

type SvgOperatorFeComposite string
const (
	// KSvgOperatorFeCompositeOver
	//
	// English:
	//
	// This value indicates that the source graphic defined in the in attribute is placed over the destination graphic
	// defined in the in2 attribute.
	//
	// Português:
	//
	// Este valor indica que o gráfico de origem definido no atributo in é colocado sobre o gráfico de destino definido
	// no atributo in2.
	KSvgOperatorFeCompositeOver SvgOperatorFeComposite = "over"

	// KSvgOperatorFeCompositeIn
	//
	// English:
	//
	// This value indicates that the parts of the source graphic defined in the in attribute that overlap the destination
	// graphic defined in the in2 attribute, replace the destination graphic.
	//
	// Português:
	//
	// Esse valor indica que as partes do gráfico de origem definidas no atributo in que se sobrepõem ao gráfico de
	// destino definido no atributo in2 substituem o gráfico de destino.
	KSvgOperatorFeCompositeIn SvgOperatorFeComposite = "in"

	// KSvgOperatorFeCompositeOut
	//
	// English:
	//
	// This value indicates that the parts of the source graphic defined in the in attribute that fall outside the
	// destination graphic defined in the in2 attribute, are displayed.
	//
	// Português:
	//
	// Esse valor indica que as partes do gráfico de origem definidas no atributo in que estão fora do gráfico de destino
	// definido no atributo in2 são exibidas.
	KSvgOperatorFeCompositeOut SvgOperatorFeComposite = "out"

	// KSvgOperatorFeCompositeAtop
	//
	// English:
	//
	// This value indicates that the parts of the source graphic defined in the in attribute, which overlap the
	// destination graphic defined in the in2 attribute, replace the destination graphic. The parts of the destination
	// graphic that do not overlap with the source graphic stay untouched.
	//
	// Português:
	//
	// Este valor indica que as partes do gráfico de origem definidas no atributo in, que se sobrepõem ao gráfico de
	// destino definido no atributo in2, substituem o gráfico de destino. As partes do gráfico de destino que não se
	// sobrepõem ao gráfico de origem permanecem intactas.
	KSvgOperatorFeCompositeAtop SvgOperatorFeComposite = "atop"

	// KSvgOperatorFeCompositeXor
	//
	// English:
	//
	// This value indicates that the non-overlapping regions of the source graphic defined in the in attribute and the
	// destination graphic defined in the in2 attribute are combined.
	//
	// Português:
	//
	// Este valor indica que as regiões não sobrepostas do gráfico de origem definido no atributo in e o gráfico de
	// destino definido no atributo in2 são combinados.
	KSvgOperatorFeCompositeXor SvgOperatorFeComposite = "xor"

	// KSvgOperatorFeCompositeLighter
	//
	// English:
	//
	// This value indicates that the sum of the source graphic defined in the in attribute and the destination graphic
	// defined in the in2 attribute is displayed.
	//
	// Português:
	//
	// Este valor indica que a soma do gráfico de origem definido no atributo in e o gráfico de destino definido no
	// atributo in2 é exibido.
	KSvgOperatorFeCompositeLighter SvgOperatorFeComposite = "lighter"

	// KSvgOperatorFeCompositeArithmetic
	//
	// English:
	//
	// This value indicates that the source graphic defined in the in attribute and the destination graphic defined in the
	// in2 attribute are combined using the following formula:
	//
	// result = k1*i1*i2 + k2*i1 + k3*i2 + k4
	//
	// where: i1 and i2 indicate the corresponding pixel channel values of the input image, which map to in and in2
	// respectively, and k1,k2,k3,and k4 indicate the values of the attributes with the same name.
	//
	// Português:
	//
	// Esse valor indica que o gráfico de origem definido no atributo in e o gráfico de destino definido no atributo in2
	// são combinados usando a seguinte fórmula:
	//
	// resultado = k1*i1*i2 + k2*i1 + k3*i2 + k4
	//
	// onde: i1 e i2 indicam os valores de canal de pixel correspondentes da imagem de entrada, que mapeiam para in e in2
	// respectivamente, e k1,k2,k3 e k4 indicam os valores dos atributos com o mesmo nome.
	KSvgOperatorFeCompositeArithmetic SvgOperatorFeComposite = "arithmetic"
)

func (SvgOperatorFeComposite) String 

func (e SvgOperatorFeComposite) String() string

type SvgOperatorFeMorphology 

type SvgOperatorFeMorphology string
const (
	// KKSvgOperatorFeCompositeErode
	//
	// English:
	//
	// This value thins the source graphic defined in the in attribute.
	//
	// Português:
	//
	// Este valor afina o gráfico de origem definido no atributo in.
	KKSvgOperatorFeCompositeErode SvgOperatorFeMorphology = "erode"

	// KKSvgOperatorFeCompositeDilate
	//
	// English:
	//
	// This value fattens the source graphic defined in the in attribute.
	//
	// Português:
	//
	// Este valor engorda o gráfico de origem definido no atributo in.
	KKSvgOperatorFeCompositeDilate SvgOperatorFeMorphology = "dilate"
)

func (SvgOperatorFeMorphology) String 

func (e SvgOperatorFeMorphology) String() string

type SvgOrient 

type SvgOrient string
const (
	// KSvgOrientAuto
	//
	// English:
	//
	// This value indicates that the marker is oriented such that its positive x-axis is pointing in a direction relative
	// to the path at the position the marker is placed.
	//
	// Português:
	//
	// Este valor indica que o marcador está orientado de forma que seu eixo x positivo esteja apontando em uma direção
	// relativa ao caminho na posição em que o marcador é colocado.
	KSvgOrientAuto SvgOrient = "auto"

	// KSvgOrientAutoStartReverse
	//
	// English:
	//
	// If placed by marker-start, the marker is oriented 180° different from the orientation that would be used if auto
	// where specified. For all other markers, auto-start-reverse means the same as auto.
	//
	//   Notes:
	//     * This allows a single arrowhead marker to be defined that can be used for both the start and end of a path,
	//       i.e. which points outwards from both ends.
	//
	// Português:
	//
	// Se colocado pelo início do marcador, o marcador é orientado 180° diferente da orientação que seria usada se auto,
	// onde especificado. Para todos os outros marcadores, auto-start-reverse significa o mesmo que auto.
	//
	//   Notas:
	//     * Isso permite definir um único marcador de ponta de seta que pode ser usado tanto para o início quanto para o
	//       final de um caminho, ou seja, que aponta para fora de ambas as extremidades.
	KSvgOrientAutoStartReverse SvgOrient = "auto-start-reverse"
)

func (SvgOrient) String 

func (e SvgOrient) String() string

type SvgPaintOrder 

type SvgPaintOrder string
const (
	// KSvgPaintOrderNormal
	//
	// English:
	//
	// This value indicates that the fill will be painted first, then the stroke, and finally the markers.
	//
	// Português:
	//
	// Esse valor indica que o preenchimento será pintado primeiro, depois o traçado e, finalmente, os marcadores.
	KSvgPaintOrderNormal SvgPaintOrder = "normal"

	// KSvgPaintOrderFill
	//
	// English:
	//
	// The order of these three keywords indicates the order in which the painting happens, from left to right. If any of
	// the three painting components is omitted, they will be painted in their default order after the specified
	// components.
	//
	// For example, using stroke is equivalent to stroke fill markers.
	//
	// Português:
	//
	// A ordem dessas três palavras-chave indica a ordem em que a pintura acontece, da esquerda para a direita. Se algum
	// dos três componentes de pintura for omitido, eles serão pintados em sua ordem padrão após os componentes
	// especificados.
	//
	// Por exemplo, usar traço é equivalente a marcadores de preenchimento de traço.
	KSvgPaintOrderFill SvgPaintOrder = "fill"

	// KSvgPaintOrderStroke
	//
	// English:
	//
	// The order of these three keywords indicates the order in which the painting happens, from left to right. If any of
	// the three painting components is omitted, they will be painted in their default order after the specified
	// components.
	//
	// For example, using stroke is equivalent to stroke fill markers.
	//
	// Português:
	//
	// A ordem dessas três palavras-chave indica a ordem em que a pintura acontece, da esquerda para a direita. Se algum
	// dos três componentes de pintura for omitido, eles serão pintados em sua ordem padrão após os componentes
	// especificados.
	//
	// Por exemplo, usar traço é equivalente a marcadores de preenchimento de traço.
	KSvgPaintOrderStroke SvgPaintOrder = "stroke"

	// KSvgPaintOrderMarkers
	//
	// English:
	//
	// The order of these three keywords indicates the order in which the painting happens, from left to right. If any of
	// the three painting components is omitted, they will be painted in their default order after the specified
	// components.
	//
	// For example, using stroke is equivalent to stroke fill markers.
	//
	// Português:
	//
	// A ordem dessas três palavras-chave indica a ordem em que a pintura acontece, da esquerda para a direita. Se algum
	// dos três componentes de pintura for omitido, eles serão pintados em sua ordem padrão após os componentes
	// especificados.
	//
	// Por exemplo, usar traço é equivalente a marcadores de preenchimento de traço.
	KSvgPaintOrderMarkers SvgPaintOrder = "markers"
)

func (SvgPaintOrder) String 

func (e SvgPaintOrder) String() string

type SvgPath 

type SvgPath struct {
	// contains filtered or unexported fields
}

func (*SvgPath) A 

func (e *SvgPath) A(rx, ry, angle, largeArcFlag, sweepFlag, x, y float64) (ref *SvgPath)

A (ArcCurve)

English: 

Draw an Arc curve from the current point to the coordinate x,y. The center of the ellipse used to draw the arc is
determined automatically based on the other parameters of the command:

 * rx and ry are the two radii of the ellipse;
 * angle represents a rotation (in degrees) of the ellipse relative to the x-axis;
 * large-arc-flag and sweep-flag allows to chose which arc must be drawn as 4 possible arcs can be drawn out of the
   other parameters.
 * large-arc-flag allows to chose one of the large arc (1) or small arc (0),
 * sweep-flag allows to chose one of the clockwise turning arc (1) or counterclockwise turning arc (0)

The coordinate x,y becomes the new current point for the next command. All subsequent sets of parameters are considered implicit absolute arc curve (A) commands.

Português: 

Desenhe uma curva de arco do ponto atual até a coordenada x,y. O centro da elipse usada para desenhar o arco é
determinado automaticamente com base nos outros parâmetros do comando:

 * rx e ry são os dois raios da elipse;
 * ângulo representa uma rotação (em graus) da elipse em relação ao eixo x;
 * large-arc-flag e sweep-flag permitem escolher qual arco deve ser desenhado, pois 4 arcos possíveis podem ser
   desenhados a partir dos outros parâmetros.
 * large-arc-flag permite escolher um arco grande (1) ou arco pequeno (0),
 * sweep-flag permite escolher um arco de giro no sentido horário (1) ou arco de giro no sentido anti-horário (0)

A coordenada x,y torna-se o novo ponto atual para o próximo comando. Todos os conjuntos de parâmetros subsequentes são considerados comandos implícitos de curva de arco absoluto (A).

func (*SvgPath) Ad 

func (e *SvgPath) Ad(rx, ry, angle, largeArcFlag, sweepFlag, dx, dy float64) (ref *SvgPath)

Ad (ArcCurveDelta)

English: 

Draw an Arc curve from the current point to a point for which coordinates are those of the current point shifted by
dx along the x-axis and dy along the y-axis. The center of the ellipse used to draw the arc is determined
automatically based on the other parameters of the command:

 * rx and ry are the two radii of the ellipse;
 * angle represents a rotation (in degrees) of the ellipse relative to the x-axis;
 * large-arc-flag and sweep-flag allows to chose which arc must be drawn as 4 possible arcs can be drawn out of the
   other parameters.
 * large-arc-flag allows a choice of large arc (1) or small arc (0),
 * sweep-flag allows a choice of a clockwise arc (1) or counterclockwise arc (0)

The current point gets its X and Y coordinates shifted by dx and dy for the next command. All subsequent sets of parameters are considered implicit relative arc curve (a) commands.

Português: 

Desenhe uma curva de arco do ponto atual para um ponto para o qual as coordenadas são as do ponto atual deslocado
por dx ao longo do eixo x e dy ao longo do eixo y. O centro da elipse usada para desenhar o arco é determinado
automaticamente com base nos outros parâmetros do comando:

 * rx e ry são os dois raios da elipse;
 * ângulo representa uma rotação (em graus) da elipse em relação ao eixo x;
 * large-arc-flag e sweep-flag permitem escolher qual arco deve ser desenhado, pois 4 arcos possíveis podem ser
   desenhados a partir dos outros parâmetros.
 * large-arc-flag permite a escolha de arco grande (1) ou arco pequeno (0),
 * A bandeira de varredura permite a escolha de um arco no sentido horário (1) ou no sentido anti-horário (0)

O ponto atual obtém suas coordenadas X e Y deslocadas por dx e dy para o próximo comando. Todos os conjuntos de parâmetros subsequentes são considerados comandos implícitos de curva de arco relativo (a).

func (*SvgPath) ArcCurve 

func (e *SvgPath) ArcCurve(rx, ry, angle, largeArcFlag, sweepFlag, x, y float64) (ref *SvgPath)

ArcCurve

English: 

Draw an Arc curve from the current point to the coordinate x,y. The center of the ellipse used to draw the arc is
determined automatically based on the other parameters of the command:

 * rx and ry are the two radii of the ellipse;
 * angle represents a rotation (in degrees) of the ellipse relative to the x-axis;
 * large-arc-flag and sweep-flag allows to chose which arc must be drawn as 4 possible arcs can be drawn out of the
   other parameters.
 * large-arc-flag allows to chose one of the large arc (1) or small arc (0),
 * sweep-flag allows to chose one of the clockwise turning arc (1) or counterclockwise turning arc (0)

The coordinate x,y becomes the new current point for the next command. All subsequent sets of parameters are considered implicit absolute arc curve (A) commands.

Português: 

Desenhe uma curva de arco do ponto atual até a coordenada x,y. O centro da elipse usada para desenhar o arco é
determinado automaticamente com base nos outros parâmetros do comando:

 * rx e ry são os dois raios da elipse;
 * ângulo representa uma rotação (em graus) da elipse em relação ao eixo x;
 * large-arc-flag e sweep-flag permitem escolher qual arco deve ser desenhado, pois 4 arcos possíveis podem ser
   desenhados a partir dos outros parâmetros.
 * large-arc-flag permite escolher um arco grande (1) ou arco pequeno (0),
 * sweep-flag permite escolher um arco de giro no sentido horário (1) ou arco de giro no sentido anti-horário (0)

A coordenada x,y torna-se o novo ponto atual para o próximo comando. Todos os conjuntos de parâmetros subsequentes são considerados comandos implícitos de curva de arco absoluto (A).

func (*SvgPath) ArcCurveDelta 

func (e *SvgPath) ArcCurveDelta(rx, ry, angle, largeArcFlag, sweepFlag, dx, dy float64) (ref *SvgPath)

ArcCurveDelta

English: 

Draw an Arc curve from the current point to a point for which coordinates are those of the current point shifted by
dx along the x-axis and dy along the y-axis. The center of the ellipse used to draw the arc is determined
automatically based on the other parameters of the command:

 * rx and ry are the two radii of the ellipse;
 * angle represents a rotation (in degrees) of the ellipse relative to the x-axis;
 * large-arc-flag and sweep-flag allows to chose which arc must be drawn as 4 possible arcs can be drawn out of the
   other parameters.
 * large-arc-flag allows a choice of large arc (1) or small arc (0),
 * sweep-flag allows a choice of a clockwise arc (1) or counterclockwise arc (0)

The current point gets its X and Y coordinates shifted by dx and dy for the next command. All subsequent sets of parameters are considered implicit relative arc curve (a) commands.

Português: 

Desenhe uma curva de arco do ponto atual para um ponto para o qual as coordenadas são as do ponto atual deslocado
por dx ao longo do eixo x e dy ao longo do eixo y. O centro da elipse usada para desenhar o arco é determinado
automaticamente com base nos outros parâmetros do comando:

 * rx e ry são os dois raios da elipse;
 * ângulo representa uma rotação (em graus) da elipse em relação ao eixo x;
 * large-arc-flag e sweep-flag permitem escolher qual arco deve ser desenhado, pois 4 arcos possíveis podem ser
   desenhados a partir dos outros parâmetros.
 * large-arc-flag permite a escolha de arco grande (1) ou arco pequeno (0),
 * A bandeira de varredura permite a escolha de um arco no sentido horário (1) ou no sentido anti-horário (0)

O ponto atual obtém suas coordenadas X e Y deslocadas por dx e dy para o próximo comando. Todos os conjuntos de parâmetros subsequentes são considerados comandos implícitos de curva de arco relativo (a).

func (*SvgPath) C 

func (e *SvgPath) C(x1, y1, x2, y2, x, y float64) (ref *SvgPath)

C (CubicBezierCurve)

English: 

Draw a cubic Bézier curve from the current point to the end point specified by x,y. The start control point is
specified by x1,y1 and the end control point is specified by x2,y2. Any subsequent triplet(s) of coordinate pairs
are interpreted as parameter(s) for implicit absolute cubic Bézier curve (C) command(s).

Formula: 

Po′ = Pn = {x, y} ;
Pcs = {x1, y1} ;
Pce = {x2, y2}

Português: 

Desenhe uma curva Bézier cúbica do ponto atual até o ponto final especificado por x,y. O ponto de controle inicial
é especificado por x1,y1 e o ponto de controle final é especificado por x2,y2. Quaisquer tripletos subsequentes de
pares de coordenadas são interpretados como parâmetro(s) para comando(s) implícito(s) da curva Bézier cúbica
absoluta (C).

Fórmula: 

Po′ = Pn = {x, y} ;
Pcs = {x1, y1} ;
Pce = {x2, y2}

func (*SvgPath) Cd 

func (e *SvgPath) Cd(dx1, dy1, dx2, dy2, dx, dy float64) (ref *SvgPath)

Cd (CubicBezierCurveDelta)

English: 

Draw a cubic Bézier curve from the current point to the end point, which is the current point shifted by dx along
the x-axis and dy along the y-axis. The start control point is the current point (starting point of the curve)
shifted by dx1 along the x-axis and dy1 along the y-axis. The end control point is the current point (starting point
of the curve) shifted by dx2 along the x-axis and dy2 along the y-axis. Any subsequent triplet(s) of coordinate
pairs are interpreted as parameter(s) for implicit relative cubic Bézier curve (c) command(s).

Formula: 

Po′ = Pn = {xo + dx, yo + dy} ;
Pcs = {xo + dx1, yo + dy1} ;
Pce = {xo + dx2, yo + dy2}

Português: 

Desenhe uma curva de Bézier cúbica do ponto atual até o ponto final, que é o ponto atual deslocado por dx ao longo
do eixo x e dy ao longo do eixo y. O ponto de controle inicial é o ponto atual (ponto inicial da curva) deslocado
por dx1 ao longo do eixo x e dy1 ao longo do eixo y. O ponto de controle final é o ponto atual (ponto inicial da
curva) deslocado por dx2 ao longo do eixo x e dy2 ao longo do eixo y. Quaisquer tripletos subsequentes de pares de coordenadas são interpretados como parâmetro(s) para o(s) comando(s) implícito(s) da curva de Bézier cúbica relativa (c).

Fórmula: 

Po′ = Pn = {xo + dx, yo + dy} ;
Pcs = {xo + dx1, yo + dy1} ;
Pce = {xo + dx2, yo + dy2}

func (*SvgPath) Close 

func (e *SvgPath) Close() (ref *SvgPath)

Close

English: 

Close the current subpath by connecting the last point of the path with its initial point. If the two points are at
different coordinates, a straight line is drawn between those two points.

 Notes:
   * The appearance of a shape closed with ClosePath may be different to that of one closed by drawing a line to
     the origin, using one of the other commands, because the line ends are joined together (according to the
     stroke-linejoin setting), rather than just being placed at the same coordinates.

Português: 

Feche o subcaminho atual conectando o último ponto do caminho com seu ponto inicial. Se os dois pontos estiverem em
coordenadas diferentes, uma linha reta será traçada entre esses dois pontos.

 Notas:
   * A aparência de uma forma fechada com ClosePath pode ser diferente daquela fechada desenhando uma linha até a
     origem, usando um dos outros comandos, porque as extremidades da linha são unidas (de acordo com a
     configuração stroke-linejoin), em vez de apenas sendo colocado nas mesmas coordenadas.

func (*SvgPath) CubicBezierCurve 

func (e *SvgPath) CubicBezierCurve(x1, y1, x2, y2, x, y float64) (ref *SvgPath)

CubicBezierCurve

English: 

Draw a cubic Bézier curve from the current point to the end point specified by x,y. The start control point is
specified by x1,y1 and the end control point is specified by x2,y2. Any subsequent triplet(s) of coordinate pairs
are interpreted as parameter(s) for implicit absolute cubic Bézier curve (C) command(s).

Formula: 

Po′ = Pn = {x, y} ;
Pcs = {x1, y1} ;
Pce = {x2, y2}

Português: 

Desenhe uma curva Bézier cúbica do ponto atual até o ponto final especificado por x,y. O ponto de controle inicial
é especificado por x1,y1 e o ponto de controle final é especificado por x2,y2. Quaisquer tripletos subsequentes de
pares de coordenadas são interpretados como parâmetro(s) para comando(s) implícito(s) da curva Bézier cúbica
absoluta (C).

Fórmula: 

Po′ = Pn = {x, y} ;
Pcs = {x1, y1} ;
Pce = {x2, y2}

func (*SvgPath) CubicBezierCurveDelta 

func (e *SvgPath) CubicBezierCurveDelta(dx1, dy1, dx2, dy2, dx, dy float64) (ref *SvgPath)

CubicBezierCurveDelta

English: 

Draw a cubic Bézier curve from the current point to the end point, which is the current point shifted by dx along
the x-axis and dy along the y-axis. The start control point is the current point (starting point of the curve)
shifted by dx1 along the x-axis and dy1 along the y-axis. The end control point is the current point (starting point
of the curve) shifted by dx2 along the x-axis and dy2 along the y-axis. Any subsequent triplet(s) of coordinate
pairs are interpreted as parameter(s) for implicit relative cubic Bézier curve (c) command(s).

Formula: 

Po′ = Pn = {xo + dx, yo + dy} ;
Pcs = {xo + dx1, yo + dy1} ;
Pce = {xo + dx2, yo + dy2}

Português: 

Desenhe uma curva de Bézier cúbica do ponto atual até o ponto final, que é o ponto atual deslocado por dx ao longo
do eixo x e dy ao longo do eixo y. O ponto de controle inicial é o ponto atual (ponto inicial da curva) deslocado
por dx1 ao longo do eixo x e dy1 ao longo do eixo y. O ponto de controle final é o ponto atual (ponto inicial da
curva) deslocado por dx2 ao longo do eixo x e dy2 ao longo do eixo y. Quaisquer tripletos subsequentes de pares de coordenadas são interpretados como parâmetro(s) para o(s) comando(s) implícito(s) da curva de Bézier cúbica relativa (c).

Fórmula: 

Po′ = Pn = {xo + dx, yo + dy} ;
Pcs = {xo + dx1, yo + dy1} ;
Pce = {xo + dx2, yo + dy2}

func (*SvgPath) H 

func (e *SvgPath) H(x float64) (ref *SvgPath)

H (HorizontalLine)

English: 

Draw a horizontal line from the current point to the end point, which is specified by the x parameter and the
current point's y coordinate. Any subsequent value(s) are interpreted as parameter(s) for implicit absolute
horizontal LineTo (H) command(s).

Formula: Po′ = Pn = {x, yo}

Português: 

Desenhe uma linha horizontal do ponto atual até o ponto final, que é especificado pelo parâmetro x e pela coordenada
y do ponto atual. Quaisquer valores subsequentes são interpretados como parâmetro(s) para comandos LineTo (H)
horizontais absolutos implícitos.

Formula: Po′ = Pn = {x, yo}

func (*SvgPath) Hd 

func (e *SvgPath) Hd(dx float64) (ref *SvgPath)

Hd (HorizontalLineDelta)

English: 

Draw a horizontal line from the current point to the end point, which is specified by the current point shifted by
dx along the x-axis and the current point's y coordinate. Any subsequent value(s) are interpreted as parameter(s)
for implicit relative horizontal LineTo (h) command(s).

Formula: Po′ = Pn = {xo + dx, yo}

Português: 

Draw a horizontal line from the current point to the end point, which is specified by the current point shifted by
dx along the x-axis and the current point's y coordinate. Any subsequent value(s) are interpreted as parameter(s)
for implicit relative horizontal LineTo (h) command(s).

Fórmula: Po′ = Pn = {xo + dx, yo}

func (*SvgPath) HorizontalLine 

func (e *SvgPath) HorizontalLine(x float64) (ref *SvgPath)

HorizontalLine

English: 

Draw a horizontal line from the current point to the end point, which is specified by the x parameter and the
current point's y coordinate. Any subsequent value(s) are interpreted as parameter(s) for implicit absolute
horizontal LineTo (H) command(s).

Formula: Po′ = Pn = {x, yo}

Português: 

Desenhe uma linha horizontal do ponto atual até o ponto final, que é especificado pelo parâmetro x e pela coordenada
y do ponto atual. Quaisquer valores subsequentes são interpretados como parâmetro(s) para comandos LineTo (H)
horizontais absolutos implícitos.

Formula: Po′ = Pn = {x, yo}

func (*SvgPath) HorizontalLineDelta 

func (e *SvgPath) HorizontalLineDelta(dx float64) (ref *SvgPath)

HorizontalLineDelta

English: 

Draw a horizontal line from the current point to the end point, which is specified by the current point shifted by
dx along the x-axis and the current point's y coordinate. Any subsequent value(s) are interpreted as parameter(s)
for implicit relative horizontal LineTo (h) command(s).

Formula: Po′ = Pn = {xo + dx, yo}

Português: 

Draw a horizontal line from the current point to the end point, which is specified by the current point shifted by
dx along the x-axis and the current point's y coordinate. Any subsequent value(s) are interpreted as parameter(s)
for implicit relative horizontal LineTo (h) command(s).

Fórmula: Po′ = Pn = {xo + dx, yo}

func (*SvgPath) L 

func (e *SvgPath) L(x, y float64) (ref *SvgPath)

L (LineTo)

English: 

Draw a line from the current point to the end point specified by x,y. Any subsequent coordinate pair(s) are
interpreted as parameter(s) for implicit absolute LineTo (L) command(s).

Formula: Po′ = Pn = {x, y}

Português: 

Desenhe uma linha do ponto atual até o ponto final especificado por x,y. Quaisquer pares de coordenadas subsequentes
são interpretados como parâmetros para comandos LineTo (L) absolutos implícitos.

Fórmula: Po′ = Pn = {x, y}

func (*SvgPath) Ld 

func (e *SvgPath) Ld(dx, dy float64) (ref *SvgPath)

Ld (LineToDelta)

English: 

Draw a line from the current point to the end point, which is the current point shifted by dx along the x-axis and
dy along the y-axis. Any subsequent coordinate pair(s) are interpreted as parameter(s) for implicit relative LineTo
(l) command(s) (see below).

Formula: Po′ = Pn = {xo + dx, yo + dy}

Português: 

Desenhe uma linha do ponto atual até o ponto final, que é o ponto atual deslocado por dx ao longo do eixo x e dy ao
longo do eixo y. Quaisquer pares de coordenadas subsequentes são interpretados como parâmetro(s) para o(s)
comando(s) LineTo (l) relativo implícito (veja abaixo).

Fórmula: Po′ = Pn = {xo + dx, yo + dy}

func (*SvgPath) LineTo 

func (e *SvgPath) LineTo(x, y float64) (ref *SvgPath)

LineTo

English: 

Draw a line from the current point to the end point specified by x,y. Any subsequent coordinate pair(s) are
interpreted as parameter(s) for implicit absolute LineTo (L) command(s).

Formula: Po′ = Pn = {x, y}

Português: 

Desenhe uma linha do ponto atual até o ponto final especificado por x,y. Quaisquer pares de coordenadas subsequentes
são interpretados como parâmetros para comandos LineTo (L) absolutos implícitos.

Fórmula: Po′ = Pn = {x, y}

func (*SvgPath) LineToDelta 

func (e *SvgPath) LineToDelta(dx, dy float64) (ref *SvgPath)

LineToDelta

English: 

Draw a line from the current point to the end point, which is the current point shifted by dx along the x-axis and
dy along the y-axis. Any subsequent coordinate pair(s) are interpreted as parameter(s) for implicit relative LineTo
(l) command(s) (see below).

Formula: Po′ = Pn = {xo + dx, yo + dy}

Português: 

Desenhe uma linha do ponto atual até o ponto final, que é o ponto atual deslocado por dx ao longo do eixo x e dy ao
longo do eixo y. Quaisquer pares de coordenadas subsequentes são interpretados como parâmetro(s) para o(s)
comando(s) LineTo (l) relativo implícito (veja abaixo).

Fórmula: Po′ = Pn = {xo + dx, yo + dy}

func (*SvgPath) M 

func (e *SvgPath) M(x, y float64) (ref *SvgPath)

M (MoveTo)

English: 

Move the current point to the coordinate x,y. Any subsequent coordinate pair(s) are interpreted as parameter(s) for
implicit absolute LineTo (L) command(s) (see below).

Formula: Pn = {x, y}

Português: 

Mova o ponto atual para a coordenada x,y. Quaisquer pares de coordenadas subsequentes são interpretados como
parâmetro(s) para comando(s) LineTo (L) absoluto implícito (veja abaixo).

Fórmula: Pn = {x, y}

func (*SvgPath) Md 

func (e *SvgPath) Md(dx, dy float64) (ref *SvgPath)

Md (MoveToDelta)

English: 

Move the current point by shifting the last known position of the path by dx along the x-axis and by dy along the
y-axis. Any subsequent coordinate pair(s) are interpreted as parameter(s) for implicit relative LineTo (l)
command(s) (see below).

Formula: Pn = {xo + dx, yo + dy}

Português: 

Mova o ponto atual deslocando a última posição conhecida do caminho por dx ao longo do eixo x e por dy ao longo do
eixo y. Quaisquer pares de coordenadas subsequentes são interpretados como parâmetro(s) para o(s) comando(s) LineTo
(l) relativo implícito (veja abaixo).

Fórmula: Pn = {xo + dx, yo + dy}

func (*SvgPath) MoveTo 

func (e *SvgPath) MoveTo(x, y float64) (ref *SvgPath)

MoveTo

English: 

Move the current point to the coordinate x,y. Any subsequent coordinate pair(s) are interpreted as parameter(s) for
implicit absolute LineTo (L) command(s) (see below).

Formula: Pn = {x, y}

Português: 

Mova o ponto atual para a coordenada x,y. Quaisquer pares de coordenadas subsequentes são interpretados como
parâmetro(s) para comando(s) LineTo (L) absoluto implícito (veja abaixo).

Fórmula: Pn = {x, y}

func (*SvgPath) MoveToDelta 

func (e *SvgPath) MoveToDelta(dx, dy float64) (ref *SvgPath)

MoveToDelta

English: 

Move the current point by shifting the last known position of the path by dx along the x-axis and by dy along the
y-axis. Any subsequent coordinate pair(s) are interpreted as parameter(s) for implicit relative LineTo (l)
command(s) (see below).

Formula: Pn = {xo + dx, yo + dy}

Português: 

Mova o ponto atual deslocando a última posição conhecida do caminho por dx ao longo do eixo x e por dy ao longo do
eixo y. Quaisquer pares de coordenadas subsequentes são interpretados como parâmetro(s) para o(s) comando(s) LineTo
(l) relativo implícito (veja abaixo).

Fórmula: Pn = {xo + dx, yo + dy}

func (*SvgPath) Q 

func (e *SvgPath) Q(x1, y1, x, y float64) (ref *SvgPath)

Q (QuadraticBezierCurve)

English: 

Draw a quadratic Bézier curve from the current point to the end point specified by x,y. The control point is
specified by x1,y1. Any subsequent pair(s) of coordinate pairs are interpreted as parameter(s) for implicit absolute
quadratic Bézier curve (Q) command(s).

Formula:
 Po′ = Pn = {x, y} ;
 Pc = {x1, y1}

Português: 

Desenhe uma curva Bézier quadrática do ponto atual até o ponto final especificado por x,y. O ponto de controle é
especificado por x1,y1. Quaisquer pares subsequentes de pares de coordenadas são interpretados como parâmetro(s)
para comando(s) de curva de Bézier (Q) quadrática absoluta implícita.

Fórmula:
 Po′ = Pn = {x, y} ;
 Pc = {x1, y1}

func (*SvgPath) Qd 

func (e *SvgPath) Qd(dx1, dy1, dx, dy float64) (ref *SvgPath)

Qd (QuadraticBezierCurveDelta)

English: 

Draw a quadratic Bézier curve from the current point to the end point, which is the current point shifted by dx
along the x-axis and dy along the y-axis. The control point is the current point (starting point of the curve)
shifted by dx1 along the x-axis and dy1 along the y-axis. Any subsequent pair(s) of coordinate pairs are interpreted
as parameter(s) for implicit relative quadratic Bézier curve (q) command(s).

Formula: 

Po′ = Pn = {xo + dx, yo + dy} ;
Pc = {xo + dx1, yo + dy1}

Português: 

Desenhe uma curva Bézier quadrática do ponto atual até o ponto final, que é o ponto atual deslocado por dx ao longo
do eixo x e dy ao longo do eixo y. O ponto de controle é o ponto atual (ponto inicial da curva) deslocado por dx1
ao longo do eixo x e dy1 ao longo do eixo y. Quaisquer pares subsequentes de pares de coordenadas são interpretados
como parâmetro(s) para o(s) comando(s) da curva de Bézier quadrática relativa implícita (q).

Fórmula: 

Po′ = Pn = {xo + dx, yo + dy} ;
Pc = {xo + dx1, yo + dy1}

func (*SvgPath) QuadraticBezierCurve 

func (e *SvgPath) QuadraticBezierCurve(x1, y1, x, y float64) (ref *SvgPath)

QuadraticBezierCurve

English: 

Draw a quadratic Bézier curve from the current point to the end point specified by x,y. The control point is
specified by x1,y1. Any subsequent pair(s) of coordinate pairs are interpreted as parameter(s) for implicit absolute
quadratic Bézier curve (Q) command(s).

Formula:
 Po′ = Pn = {x, y} ;
 Pc = {x1, y1}

Português: 

Desenhe uma curva Bézier quadrática do ponto atual até o ponto final especificado por x,y. O ponto de controle é
especificado por x1,y1. Quaisquer pares subsequentes de pares de coordenadas são interpretados como parâmetro(s)
para comando(s) de curva de Bézier (Q) quadrática absoluta implícita.

Fórmula:
 Po′ = Pn = {x, y} ;
 Pc = {x1, y1}

func (*SvgPath) QuadraticBezierCurveDelta 

func (e *SvgPath) QuadraticBezierCurveDelta(dx1, dy1, dx, dy float64) (ref *SvgPath)

QuadraticBezierCurveDelta

English: 

Draw a quadratic Bézier curve from the current point to the end point, which is the current point shifted by dx
along the x-axis and dy along the y-axis. The control point is the current point (starting point of the curve)
shifted by dx1 along the x-axis and dy1 along the y-axis. Any subsequent pair(s) of coordinate pairs are interpreted
as parameter(s) for implicit relative quadratic Bézier curve (q) command(s).

Formula: 

Po′ = Pn = {xo + dx, yo + dy} ;
Pc = {xo + dx1, yo + dy1}

Português: 

Desenhe uma curva Bézier quadrática do ponto atual até o ponto final, que é o ponto atual deslocado por dx ao longo
do eixo x e dy ao longo do eixo y. O ponto de controle é o ponto atual (ponto inicial da curva) deslocado por dx1
ao longo do eixo x e dy1 ao longo do eixo y. Quaisquer pares subsequentes de pares de coordenadas são interpretados
como parâmetro(s) para o(s) comando(s) da curva de Bézier quadrática relativa implícita (q).

Fórmula: 

Po′ = Pn = {xo + dx, yo + dy} ;
Pc = {xo + dx1, yo + dy1}

func (*SvgPath) S 

func (e *SvgPath) S(x2, y2, x, y float64) (ref *SvgPath)

S (SmoothCubicBezier)

English: 

Draw a smooth cubic Bézier curve from the current point to the end point specified by x,y. The end control point is
specified by x2,y2. The start control point is a reflection of the end control point of the previous curve command.
If the previous command wasn't a cubic Bézier curve, the start control point is the same as the curve starting point
(current point). Any subsequent pair(s) of coordinate pairs are interpreted as parameter(s) for implicit absolute
smooth cubic Bézier curve (S) commands.

Português: 

Desenhe uma curva Bézier cúbica suave do ponto atual até o ponto final especificado por x,y. O ponto de controle
final é especificado por x2,y2. O ponto de controle inicial é um reflexo do ponto de controle final do comando de
curva anterior. Se o comando anterior não era uma curva Bézier cúbica, o ponto de controle inicial é o mesmo que o
ponto inicial da curva (ponto atual). Quaisquer pares subsequentes de pares de coordenadas são interpretados como
parâmetros para comandos implícitos de curva Bézier cúbica suave absoluta (S).

func (*SvgPath) Sd 

func (e *SvgPath) Sd(dx2, dy2, dx, dy float64) (ref *SvgPath)

Sd (SmoothCubicBezierDelta)

English: 

Draw a smooth cubic Bézier curve from the current point to the end point, which is the current point shifted by dx
along the x-axis and dy along the y-axis. The end control point is the current point (starting point of the curve)
shifted by dx2 along the x-axis and dy2 along the y-axis. The start control point is a reflection of the end control
point of the previous curve command. If the previous command wasn't a cubic Bézier curve, the start control point is
the same as the curve starting point (current point). Any subsequent pair(s) of coordinate pairs are interpreted as
parameter(s) for implicit relative smooth cubic Bézier curve (s) commands.

Português: 

Desenhe uma curva de Bézier cúbica suave do ponto atual ao ponto final, que é o ponto atual deslocado por dx ao
longo do eixo x e dy ao longo do eixo y. O ponto de controle final é o ponto atual (ponto inicial da curva)
deslocado por dx2 ao longo do eixo x e dy2 ao longo do eixo y. O ponto de controle inicial é um reflexo do ponto de
controle final do comando de curva anterior. Se o comando anterior não era uma curva Bézier cúbica, o ponto de
controle inicial é o mesmo que o ponto inicial da curva (ponto atual). Quaisquer pares subsequentes de pares de
coordenadas são interpretados como parâmetro(s) para comandos implícitos de curva(s) Bézier cúbica suave relativa.

func (*SvgPath) SmoothCubicBezier 

func (e *SvgPath) SmoothCubicBezier(x2, y2, x, y float64) (ref *SvgPath)

SmoothCubicBezier

English: 

Draw a smooth cubic Bézier curve from the current point to the end point specified by x,y. The end control point is
specified by x2,y2. The start control point is a reflection of the end control point of the previous curve command.
If the previous command wasn't a cubic Bézier curve, the start control point is the same as the curve starting point
(current point). Any subsequent pair(s) of coordinate pairs are interpreted as parameter(s) for implicit absolute
smooth cubic Bézier curve (S) commands.

Português: 

Desenhe uma curva Bézier cúbica suave do ponto atual até o ponto final especificado por x,y. O ponto de controle
final é especificado por x2,y2. O ponto de controle inicial é um reflexo do ponto de controle final do comando de
curva anterior. Se o comando anterior não era uma curva Bézier cúbica, o ponto de controle inicial é o mesmo que o
ponto inicial da curva (ponto atual). Quaisquer pares subsequentes de pares de coordenadas são interpretados como
parâmetros para comandos implícitos de curva Bézier cúbica suave absoluta (S).

func (*SvgPath) SmoothCubicBezierDelta 

func (e *SvgPath) SmoothCubicBezierDelta(dx2, dy2, dx, dy float64) (ref *SvgPath)

SmoothCubicBezierDelta

English: 

Draw a smooth cubic Bézier curve from the current point to the end point, which is the current point shifted by dx
along the x-axis and dy along the y-axis. The end control point is the current point (starting point of the curve)
shifted by dx2 along the x-axis and dy2 along the y-axis. The start control point is a reflection of the end control
point of the previous curve command. If the previous command wasn't a cubic Bézier curve, the start control point is
the same as the curve starting point (current point). Any subsequent pair(s) of coordinate pairs are interpreted as
parameter(s) for implicit relative smooth cubic Bézier curve (s) commands.

Português: 

Desenhe uma curva de Bézier cúbica suave do ponto atual ao ponto final, que é o ponto atual deslocado por dx ao
longo do eixo x e dy ao longo do eixo y. O ponto de controle final é o ponto atual (ponto inicial da curva)
deslocado por dx2 ao longo do eixo x e dy2 ao longo do eixo y. O ponto de controle inicial é um reflexo do ponto de
controle final do comando de curva anterior. Se o comando anterior não era uma curva Bézier cúbica, o ponto de
controle inicial é o mesmo que o ponto inicial da curva (ponto atual). Quaisquer pares subsequentes de pares de
coordenadas são interpretados como parâmetro(s) para comandos implícitos de curva(s) Bézier cúbica suave relativa.

func (*SvgPath) SmoothQuadraticBezierCurve 

func (e *SvgPath) SmoothQuadraticBezierCurve(x, y float64) (ref *SvgPath)

SmoothQuadraticBezierCurve

English: 

Draw a smooth quadratic Bézier curve from the current point to the end point specified by x,y. The control point is
a reflection of the control point of the previous curve command. If the previous command wasn't a quadratic Bézier
curve, the control point is the same as the curve starting point (current point). Any subsequent coordinate pair(s)
are interpreted as parameter(s) for implicit absolute smooth quadratic Bézier curve (T) command(s).

Formula: 

Po′ = Pn = {x, y}

Português: 

Desenhe uma curva Bézier quadrática suave do ponto atual até o ponto final especificado por x,y. O ponto de controle
é um reflexo do ponto de controle do comando de curva anterior. Se o comando anterior não for uma curva Bézier
quadrática, o ponto de controle é o mesmo que o ponto inicial da curva (ponto atual). Quaisquer pares de coordenadas
subsequentes são interpretados como parâmetro(s) para comando(s) de curva de Bézier (T) quadrática suave absoluta
implícita.

Formula: 

Po′ = Pn = {x, y}

func (*SvgPath) SmoothQuadraticBezierCurveDelta 

func (e *SvgPath) SmoothQuadraticBezierCurveDelta(dx, dy float64) (ref *SvgPath)

SmoothQuadraticBezierCurveDelta

English: 

Draw a smooth quadratic Bézier curve from the current point to the end point, which is the current point shifted by
dx along the x-axis and dy along the y-axis. The control point is a reflection of the control point of the previous
curve command. If the previous command wasn't a quadratic Bézier curve, the control point is the same as the curve
starting point (current point). Any subsequent coordinate pair(s) are interpreted as parameter(s) for implicit
relative smooth quadratic Bézier curve (t) command(s).

Formulae: 

Po′ = Pn = {xo + dx, yo + dy}

Português: 

Desenhe uma curva Bézier quadrática suave do ponto atual até o ponto final, que é o ponto atual deslocado por dx ao
longo do eixo x e dy ao longo do eixo y. O ponto de controle é um reflexo do ponto de controle do comando de curva
anterior. Se o comando anterior não for uma curva Bézier quadrática, o ponto de controle é o mesmo que o ponto
inicial da curva (ponto atual). Quaisquer pares de coordenadas subsequentes são interpretados como parâmetro(s) para
comando(s) de curva de Bézier (t) quadrática suave relativa implícita.

Formulae: 

Po′ = Pn = {xo + dx, yo + dy}

func (SvgPath) String 

func (e SvgPath) String() (path string)

String

English: 

Returns the string formed with the SVG path

Português: 

Retorna a string formada com o path SVG

func (*SvgPath) T 

func (e *SvgPath) T(x, y float64) (ref *SvgPath)

T (SmoothQuadraticBezierCurve)

English: 

Draw a smooth quadratic Bézier curve from the current point to the end point specified by x,y. The control point is
a reflection of the control point of the previous curve command. If the previous command wasn't a quadratic Bézier
curve, the control point is the same as the curve starting point (current point). Any subsequent coordinate pair(s)
are interpreted as parameter(s) for implicit absolute smooth quadratic Bézier curve (T) command(s).

Formula: 

Po′ = Pn = {x, y}

Português: 

Desenhe uma curva Bézier quadrática suave do ponto atual até o ponto final especificado por x,y. O ponto de controle
é um reflexo do ponto de controle do comando de curva anterior. Se o comando anterior não for uma curva Bézier
quadrática, o ponto de controle é o mesmo que o ponto inicial da curva (ponto atual). Quaisquer pares de coordenadas
subsequentes são interpretados como parâmetro(s) para comando(s) de curva de Bézier (T) quadrática suave absoluta
implícita.

Formula: 

Po′ = Pn = {x, y}

func (*SvgPath) Td 

func (e *SvgPath) Td(dx, dy float64) (ref *SvgPath)

Td (SmoothQuadraticBezierCurveDelta)

English: 

Draw a smooth quadratic Bézier curve from the current point to the end point, which is the current point shifted by
dx along the x-axis and dy along the y-axis. The control point is a reflection of the control point of the previous
curve command. If the previous command wasn't a quadratic Bézier curve, the control point is the same as the curve
starting point (current point). Any subsequent coordinate pair(s) are interpreted as parameter(s) for implicit
relative smooth quadratic Bézier curve (t) command(s).

Formulae: 

Po′ = Pn = {xo + dx, yo + dy}

Português: 

Desenhe uma curva Bézier quadrática suave do ponto atual até o ponto final, que é o ponto atual deslocado por dx ao
longo do eixo x e dy ao longo do eixo y. O ponto de controle é um reflexo do ponto de controle do comando de curva
anterior. Se o comando anterior não for uma curva Bézier quadrática, o ponto de controle é o mesmo que o ponto
inicial da curva (ponto atual). Quaisquer pares de coordenadas subsequentes são interpretados como parâmetro(s) para
comando(s) de curva de Bézier (t) quadrática suave relativa implícita.

Formulae: 

Po′ = Pn = {xo + dx, yo + dy}

func (*SvgPath) V 

func (e *SvgPath) V(y float64) (ref *SvgPath)

V (VerticalLine)

English: 

Draw a vertical line from the current point to the end point, which is specified by the y parameter and the current
point's x coordinate. Any subsequent values are interpreted as parameters for implicit absolute vertical LineTo (V)
command(s).

Formula: Po′ = Pn = {xo, y}

Português: 

Draw a vertical line from the current point to the end point, which is specified by the y parameter and the current
point's x coordinate. Any subsequent values are interpreted as parameters for implicit absolute vertical LineTo (V)
command(s).

Fórmula: Po′ = Pn = {xo, y}

func (*SvgPath) Vd 

func (e *SvgPath) Vd(dy float64) (ref *SvgPath)

Vd (VerticalLineDelta)

English: 

Draw a vertical line from the current point to the end point, which is specified by the current point shifted by dy
along the y-axis and the current point's x coordinate. Any subsequent value(s) are interpreted as parameter(s) for
implicit relative vertical LineTo (v) command(s).

Formula: Po′ = Pn = {xo, yo + dy} 

Draw a vertical line from the current point to the end point, which is specified by the current point shifted by dy
along the y-axis and the current point's x coordinate. Any subsequent value(s) are interpreted as parameter(s) for
implicit relative vertical LineTo (v) command(s).

Fórmula: Po′ = Pn = {xo, yo + dy}

Português: 

Desenhe uma linha vertical do ponto atual até o ponto final, que é especificado pelo ponto atual deslocado por dy
ao longo do eixo y e a coordenada x do ponto atual. Quaisquer valores subsequentes são interpretados como
parâmetro(s) para comando(s) vertical(is) LineTo (v) relativo implícito.

Formula: Po′ = Pn = {xo, yo + dy}

func (*SvgPath) VerticalLine 

func (e *SvgPath) VerticalLine(y float64) (ref *SvgPath)

VerticalLine

English: 

Draw a vertical line from the current point to the end point, which is specified by the y parameter and the current
point's x coordinate. Any subsequent values are interpreted as parameters for implicit absolute vertical LineTo (V)
command(s).

Formula: Po′ = Pn = {xo, y}

Português: 

Draw a vertical line from the current point to the end point, which is specified by the y parameter and the current
point's x coordinate. Any subsequent values are interpreted as parameters for implicit absolute vertical LineTo (V)
command(s).

Fórmula: Po′ = Pn = {xo, y}

func (*SvgPath) VerticalLineDelta 

func (e *SvgPath) VerticalLineDelta(dy float64) (ref *SvgPath)

VerticalLineDelta

English: 

Draw a vertical line from the current point to the end point, which is specified by the current point shifted by dy
along the y-axis and the current point's x coordinate. Any subsequent value(s) are interpreted as parameter(s) for
implicit relative vertical LineTo (v) command(s).

Formula: Po′ = Pn = {xo, yo + dy} 

Draw a vertical line from the current point to the end point, which is specified by the current point shifted by dy
along the y-axis and the current point's x coordinate. Any subsequent value(s) are interpreted as parameter(s) for
implicit relative vertical LineTo (v) command(s).

Fórmula: Po′ = Pn = {xo, yo + dy}

Português: 

Desenhe uma linha vertical do ponto atual até o ponto final, que é especificado pelo ponto atual deslocado por dy
ao longo do eixo y e a coordenada x do ponto atual. Quaisquer valores subsequentes são interpretados como
parâmetro(s) para comando(s) vertical(is) LineTo (v) relativo implícito.

Formula: Po′ = Pn = {xo, yo + dy}

func (*SvgPath) Z 

func (e *SvgPath) Z() (ref *SvgPath)

Z (Close)

English: 

Close the current subpath by connecting the last point of the path with its initial point. If the two points are at
different coordinates, a straight line is drawn between those two points.

 Notes:
   * The appearance of a shape closed with ClosePath may be different to that of one closed by drawing a line to
     the origin, using one of the other commands, because the line ends are joined together (according to the
     stroke-linejoin setting), rather than just being placed at the same coordinates.

Português: 

Feche o subcaminho atual conectando o último ponto do caminho com seu ponto inicial. Se os dois pontos estiverem em
coordenadas diferentes, uma linha reta será traçada entre esses dois pontos.

 Notas:
   * A aparência de uma forma fechada com ClosePath pode ser diferente daquela fechada desenhando uma linha até a
     origem, usando um dos outros comandos, porque as extremidades da linha são unidas (de acordo com a
     configuração stroke-linejoin), em vez de apenas sendo colocado nas mesmas coordenadas.

type SvgPointerEvents 

type SvgPointerEvents string
const (
	KSvgPointerEventsBoundingBox    SvgPointerEvents = "bounding-box"
	KSvgPointerEventsVisiblePainted SvgPointerEvents = "visiblePainted"
	KSvgPointerEventsVisibleFill    SvgPointerEvents = "visibleFill"
	KSvgPointerEventsVisibleStroke  SvgPointerEvents = "visibleStroke"
	KSvgPointerEventsVisible        SvgPointerEvents = "visible"
	KSvgPointerEventsPainted        SvgPointerEvents = "painted"
	KSvgPointerEventsFill           SvgPointerEvents = "fill"
	KSvgPointerEventsStroke         SvgPointerEvents = "stroke"
	KSvgPointerEventsAll            SvgPointerEvents = "all"
	KSvgPointerEventsNone           SvgPointerEvents = "none"
)

func (SvgPointerEvents) String 

func (e SvgPointerEvents) String() string

type SvgRotate 

type SvgRotate string
const (
	KSvgRotateAuto        SvgRotate = "auto"
	KSvgRotateAutoReverse SvgRotate = "auto-reverse"
)

func (SvgRotate) String 

func (e SvgRotate) String() string

type SvgShapeRendering 

type SvgShapeRendering string
const (
	// KSvgShapeRenderingAuto
	//
	// English:
	//
	// This value indicates that the user agent shall make appropriate tradeoffs to balance speed, crisp edges and
	// geometric precision, but with geometric precision given more importance than speed and crisp edges.
	//
	// Português:
	//
	// Esse valor indica que o agente do usuário deve fazer compensações apropriadas para equilibrar velocidade, bordas
	// nítidas e precisão geométrica, mas com precisão geométrica dada mais importância do que velocidade e bordas nítidas.
	KSvgShapeRenderingAuto SvgShapeRendering = "auto"

	// KSvgShapeRenderingOptimizeSpeed
	//
	// English:
	//
	// This value indicates that the user agent shall emphasize rendering speed over geometric precision and crisp edges.
	// This option will sometimes cause the user agent to turn off shape anti-aliasing.
	//
	// Português:
	//
	// Esse valor indica que o agente do usuário deve enfatizar a velocidade de renderização sobre a precisão geométrica
	// e as bordas nítidas.
	// Essa opção às vezes fará com que o agente do usuário desative o anti-aliasing de forma.
	KSvgShapeRenderingOptimizeSpeed SvgShapeRendering = "optimizeSpeed"

	// KSvgShapeRenderingCrispEdges
	//
	// English:
	//
	// This value indicates that the user agent shall attempt to emphasize the contrast between clean edges of artwork
	// over rendering speed and geometric precision. To achieve crisp edges, the user agent might turn off anti-aliasing
	// for all lines and curves or possibly just for straight lines which are close to vertical or horizontal.
	// Also, the user agent might adjust line positions and line widths to align edges with device pixels.
	//
	// Português:
	//
	// Esse valor indica que o agente do usuário deve tentar enfatizar o contraste entre as bordas limpas do trabalho
	// artístico sobre a velocidade de renderização e a precisão geométrica. Para obter bordas nítidas, o agente do
	// usuário pode desativar o anti-aliasing para todas as linhas e curvas ou possivelmente apenas para linhas retas
	// próximas à vertical ou horizontal. Além disso, o agente do usuário pode ajustar as posições e larguras de linha
	// para alinhar as bordas com os pixels do dispositivo.
	KSvgShapeRenderingCrispEdges SvgShapeRendering = "crispEdges"

	// KSvgShapeRenderingGeometricPrecision
	//
	// English:
	//
	// Indicates that the user agent shall emphasize geometric precision over speed and crisp edges.
	//
	// Português:
	//
	// Indica que o agente do usuário deve enfatizar a precisão geométrica sobre a velocidade e as bordas nítidas.
	KSvgShapeRenderingGeometricPrecision SvgShapeRendering = "geometricPrecision"
)

func (SvgShapeRendering) String 

func (e SvgShapeRendering) String() string

type SvgSide 

type SvgSide string
const (

	// KSvgSideLeft
	//
	// English:
	//
	// This value places the text on the left side of the path (relative to the path direction).
	//
	// Português:
	//
	// Esse valor coloca o texto no lado esquerdo do caminho (em relação à direção do caminho).
	KSvgSideLeft SvgSide = "left"

	// KSvgSideRight
	//
	// English:
	//
	// This value places the text on the right side of the path (relative to the path direction).
	// This effectively reverses the path direction.
	//
	// Português:
	//
	// Esse valor coloca o texto no lado direito do caminho (em relação à direção do caminho).
	// Isso efetivamente inverte a direção do caminho.
	KSvgSideRight SvgSide = "right"
)

func (SvgSide) String 

func (e SvgSide) String() string

type SvgSpacing 

type SvgSpacing string
const (
	// KSvgSpacingAuto
	//
	// English:
	//
	// This value indicates that the user agent should use text-on-a-path layout algorithms to adjust the spacing between
	// typographic characters in order to achieve visually appealing results.
	//
	// Português:
	//
	// Esse valor indica que o agente do usuário deve usar algoritmos de layout de texto em um caminho para ajustar o
	// espaçamento entre caracteres tipográficos para obter resultados visualmente atraentes.
	KSvgSpacingAuto SvgSpacing = "auto"

	// KSvgSpacingExact
	//
	// English:
	//
	// This value indicates that the typographic characters should be rendered exactly according to the spacing rules as
	// specified by the layout rules for text-on-a-path.
	//
	// Português:
	//
	// Esse valor indica que os caracteres tipográficos devem ser renderizados exatamente de acordo com as regras de
	// espaçamento especificadas pelas regras de layout para texto em um caminho.
	KSvgSpacingExact SvgSpacing = "exact"
)

func (SvgSpacing) String 

func (e SvgSpacing) String() string

type SvgSpreadMethod 

type SvgSpreadMethod string
const (
	// KSvgSpreadMethodPad
	//
	// English:
	//
	// This value indicates that the final color of the gradient fills the shape beyond the gradient's edges.
	//
	// Português:
	//
	// Esse valor indica que a cor final do gradiente preenche a forma além das bordas do gradiente.
	KSvgSpreadMethodPad SvgSpreadMethod = "pad"

	// KSvgSpreadMethodReflect
	//
	// English:
	//
	// This value indicates that the gradient repeats in reverse beyond its edges.
	//
	// Português:
	//
	// Este valor indica que o gradiente se repete em sentido inverso além de suas bordas.
	KSvgSpreadMethodReflect SvgSpreadMethod = "reflect"

	// KSvgSpreadMethodRepeat
	//
	// English:
	//
	// This value indicates that the gradient repeats in reverse beyond its edges.
	//
	// Português:
	//
	// Este valor indica que o gradiente se repete em sentido inverso além de suas bordas.
	KSvgSpreadMethodRepeat SvgSpreadMethod = "repeat"
)

func (SvgSpreadMethod) String 

func (e SvgSpreadMethod) String() string

type SvgStitchTiles 

type SvgStitchTiles string
const (
	// KSvgStitchTilesNoStitch
	//
	// English:
	//
	// This value indicates that no attempt is made to achieve smooth transitions at the border of tiles which contain a
	// turbulence function. Sometimes the result will show clear discontinuities at the tile borders.
	//
	// Português:
	//
	// Este valor indica que nenhuma tentativa é feita para obter transições suaves na borda dos ladrilhos que contêm uma
	// função de turbulência. Às vezes, o resultado mostrará descontinuidades claras nas bordas do ladrilho.
	KSvgStitchTilesNoStitch SvgStitchTiles = "noStitch"

	// KSvgStitchTilesStitch
	//
	// English:
	//
	// This value indicates that the user agent will automatically adjust the x and y values of the base frequency such
	// that the <feTurbulence> node's width and height (i.e., the width and height of the current subregion) contain an
	// integral number of the tile width and height for the first octave.
	//
	// Português:
	//
	// Esse valor indica que o agente do usuário ajustará automaticamente os valores x e y da frequência base de modo que
	// a largura e a altura do nó <feTurbulence> (ou seja, a largura e a altura da sub-região atual) contenham um número
	// inteiro da largura do bloco e altura para a primeira oitava.
	KSvgStitchTilesStitch SvgStitchTiles = "stitch"
)

func (SvgStitchTiles) String 

func (e SvgStitchTiles) String() string

type SvgStrokeLinecap 

type SvgStrokeLinecap string
const (
	// KSvgStrokeLinecapButt
	//
	// English:
	//
	// The butt value indicates that the stroke for each subpath does not extend beyond its two endpoints.
	// On a zero length subpath, the path will not be rendered at all.
	//
	// Português:
	//
	// O valor de extremidade indica que o traço para cada subcaminho não se estende além de seus dois pontos finais.
	// Em um subcaminho de comprimento zero, o caminho não será renderizado.
	//
	// todo: exemplo https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-linecap#butt
	KSvgStrokeLinecapButt SvgStrokeLinecap = "butt"

	// KSvgStrokeLinecapRound
	//
	// English:
	//
	// The round value indicates that at the end of each subpath the stroke will be extended by a half circle with a
	// diameter equal to the stroke width. On a zero length subpath, the stroke consists of a full circle centered at the
	// subpath's point.
	//
	// Português:
	//
	// O valor arredondado indica que no final de cada subcaminho o traço será estendido por um semicírculo com um
	// diâmetro igual à largura do traço. Em um subcaminho de comprimento zero, o traçado consiste em um círculo completo
	// centrado no ponto do subcaminho.
	//
	// todo: exemplo: https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-linecap#round
	KSvgStrokeLinecapRound SvgStrokeLinecap = "round"

	// KSvgStrokeLinecapSquare
	//
	// English:
	//
	// The square value indicates that at the end of each subpath the stroke will be extended by a rectangle with a width
	// equal to half the width of the stroke and a height equal to the width of the stroke. On a zero length subpath, the
	// stroke consists of a square with its width equal to the stroke width, centered at the subpath's point.
	//
	// Português:
	//
	// O valor quadrado indica que no final de cada subcaminho o traço será estendido por um retângulo com largura igual
	// à metade da largura do traço e altura igual à largura do traço. Em um subcaminho de comprimento zero, o traçado
	// consiste em um quadrado com sua largura igual à largura do traçado, centralizado no ponto do subcaminho.
	//
	// todo: exemplo: https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-linecap#square
	KSvgStrokeLinecapSquare SvgStrokeLinecap = "square"
)

func (SvgStrokeLinecap) String 

func (e SvgStrokeLinecap) String() string

type SvgStrokeLinejoin 

type SvgStrokeLinejoin string
const (
	// KSvgStrokeLinejoinArcs
	//
	// English:
	//
	// The arcs value indicates that an arcs corner is to be used to join path segments. The arcs shape is formed by
	// extending the outer edges of the stroke at the join point with arcs that have the same curvature as the outer edges
	// at the join point.
	//
	// Português:
	//
	// O valor de arcos indica que um canto de arco deve ser usado para unir segmentos de caminho. A forma dos arcos é
	// formada estendendo as bordas externas do traço no ponto de junção com arcos que têm a mesma curvatura das bordas
	// externas no ponto de junção.
	//
	// todo: exemplo: https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-linejoin#arcs
	KSvgStrokeLinejoinArcs SvgStrokeLinejoin = "arcs"

	// KSvgStrokeLinejoinBevel
	//
	// English:
	//
	// The bevel value indicates that a bevelled corner is to be used to join path segments.
	//
	// Português:
	//
	// O valor de chanfro indica que um canto chanfrado deve ser usado para unir segmentos de caminho.
	//
	// todo: exemplo: https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-linejoin#bevel
	KSvgStrokeLinejoinBevel SvgStrokeLinejoin = "bevel"

	// KSvgStrokeLinejoinMiter
	//
	// English:
	//
	// The miter value indicates that a sharp corner is to be used to join path segments. The corner is formed by
	// extending the outer edges of the stroke at the tangents of the path segments until they intersect.
	//
	// Português:
	//
	// O valor da mitra indica que um canto agudo deve ser usado para unir segmentos de caminho. O canto é formado
	// estendendo as bordas externas do traçado nas tangentes dos segmentos de caminho até que eles se cruzem.
	//
	// todo: exemplo: https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-linejoin#miter
	KSvgStrokeLinejoinMiter SvgStrokeLinejoin = "miter"

	// KSvgStrokeLinejoinMiterClip
	//
	// English:
	//
	// The miter-clip value indicates that a sharp corner is to be used to join path segments. The corner is formed by
	// extending the outer edges of the stroke at the tangents of the path segments until they intersect.
	//
	// If the stroke-miterlimit is exceeded, the miter is clipped at a distance equal to half the stroke-miterlimit value
	// multiplied by the stroke width from the intersection of the path segments. This provides a better rendering than
	// miter on very sharp join or in case of an animation.
	//
	// Português:
	//
	// O valor de clipe de mitra indica que um canto agudo deve ser usado para unir segmentos de caminho. O canto é
	// formado estendendo as bordas externas do traçado nas tangentes dos segmentos de caminho até que eles se cruzem.
	//
	// Se o stroke-miterlimit for excedido, a mitra é cortada a uma distância igual à metade do valor stroke-miterlimit
	// multiplicado pela largura do traço da interseção dos segmentos do caminho. Isso fornece uma renderização melhor do
	// que a mitra em uma junção muito nítida ou no caso de uma animação.
	//
	// todo: exemplo: https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-linejoin#miter-clip
	KSvgStrokeLinejoinMiterClip SvgStrokeLinejoin = "miter-clip"

	// KSvgStrokeLinejoinRound
	//
	// English:
	//
	// The round value indicates that a round corner is to be used to join path segments.
	//
	// Português:
	//
	// O valor arredondado indica que um canto arredondado deve ser usado para unir segmentos de caminho.
	//
	// todo: exemplo: https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-linejoin#round
	KSvgStrokeLinejoinRound SvgStrokeLinejoin = "round"
)

func (SvgStrokeLinejoin) String 

func (e SvgStrokeLinejoin) String() string

type SvgTextAnchor 

type SvgTextAnchor string
const (
	// KSvgTextAnchorStart
	//
	// English:
	//
	// The rendered characters are aligned such that the start of the text string is at the initial current text position.
	// For an element with a direction property value of ltr (typical for most European languages), the left side of the
	// text is rendered at the initial text position. For an element with a direction property value of rtl (typical for
	// Arabic and Hebrew), the right side of the text is rendered at the initial text position. For an element with a
	// vertical primary text direction (often typical for Asian text), the top side of the text is rendered at the initial
	// text position.
	//
	// Português:
	//
	// Os caracteres renderizados são alinhados de forma que o início da string de texto esteja na posição inicial do
	// texto atual. Para um elemento com um valor de propriedade de direção de ltr (típico para a maioria dos idiomas
	// europeus), o lado esquerdo do texto é renderizado na posição inicial do texto. Para um elemento com um valor de
	// propriedade de direção de rtl (típico para árabe e hebraico), o lado direito do texto é renderizado na posição
	// inicial do texto. Para um elemento com uma direção de texto primária vertical (geralmente típica para texto
	// asiático), o lado superior do texto é renderizado na posição inicial do texto.
	KSvgTextAnchorStart SvgTextAnchor = "start"

	// KSvgTextAnchorMiddle
	//
	// English:
	//
	// The rendered characters are aligned such that the middle of the text string is at the current text position.
	// (For text on a path, conceptually the text string is first laid out in a straight line. The midpoint between the
	// start of the text string and the end of the text string is determined. Then, the text string is mapped onto the
	// path with this midpoint placed at the current text position.)
	//
	// Português:
	//
	// Os caracteres renderizados são alinhados de forma que o meio da string de texto esteja na posição atual do texto.
	// (Para texto em um caminho, conceitualmente a string de texto é primeiro disposta em uma linha reta.
	// O ponto médio entre o início da string de texto e o final da string de texto é determinado. Em seguida, a string
	// de texto é mapeada no caminho com este ponto médio colocado na posição atual do texto.)
	KSvgTextAnchorMiddle SvgTextAnchor = "middle"

	// KSvgTextAnchorEnd
	//
	// English:
	//
	// The rendered characters are shifted such that the end of the resulting rendered text (final current text position
	// before applying the text-anchor property) is at the initial current text position. For an element with a direction
	// property value of ltr (typical for most European languages), the right side of the text is rendered at the initial
	// text position. For an element with a direction property value of rtl (typical for Arabic and Hebrew), the left
	// side of the text is rendered at the initial text position. For an element with a vertical primary text direction
	// (often typical for Asian text), the bottom of the text is rendered at the initial text position.
	//
	// Português:
	//
	// Os caracteres renderizados são deslocados de forma que o final do texto renderizado resultante (posição final do
	// texto atual antes de aplicar a propriedade text-anchor) fique na posição inicial do texto atual. Para um elemento
	// com um valor de propriedade de direção de ltr (típico para a maioria dos idiomas europeus), o lado direito do texto
	// é renderizado na posição inicial do texto. Para um elemento com um valor de propriedade de direção de rtl (típico
	// para árabe e hebraico), o lado esquerdo do texto é renderizado na posição inicial do texto. Para um elemento com
	// uma direção de texto primária vertical (geralmente típica de texto asiático), a parte inferior do texto é
	// renderizada na posição inicial do texto.
	KSvgTextAnchorEnd SvgTextAnchor = "end"
)

func (SvgTextAnchor) String 

func (e SvgTextAnchor) String() string

type SvgTextDecorationLine 

type SvgTextDecorationLine string

SvgTextDecorationLine

English:

The text-decoration-line CSS property sets the kind of decoration that is used on text in an element, such as an underline or overline.

Português:

A propriedade CSS text-decoration-line define o tipo de decoração usada no texto em um elemento, como sublinhado ou overline. 

const (
	// KSvgTextDecorationLineNone
	//
	// English:
	//
	// Produces no text decoration.
	//
	// Português:
	//
	// Não produz decoração de texto.
	KSvgTextDecorationLineNone SvgTextDecorationLine = "none"

	// KSvgTextDecorationLineUnderline
	//
	// English:
	//
	// Each line of text has a decorative line beneath it.
	//
	// Português:
	//
	// Cada linha de texto tem uma linha decorativa abaixo dela.
	KSvgTextDecorationLineUnderline SvgTextDecorationLine = "underline"

	// KSvgTextDecorationLineOverline
	//
	// English:
	//
	// Each line of text has a decorative line above it.
	//
	// Português:
	//
	// Cada linha de texto tem uma linha decorativa acima dela.
	KSvgTextDecorationLineOverline SvgTextDecorationLine = "overline"

	// KSvgTextDecorationLineLineThrough
	//
	// English:
	//
	// Each line of text has a decorative line going through its middle.
	//
	// Português:
	//
	// Cada linha de texto tem uma linha decorativa passando pelo meio.
	KSvgTextDecorationLineLineThrough SvgTextDecorationLine = "line-through"
)

func (SvgTextDecorationLine) String 

func (e SvgTextDecorationLine) String() string

type SvgTextDecorationStyle 

type SvgTextDecorationStyle string
const (
	// KSvgTextDecorationStyleSolid
	//
	// English:
	//
	// Draws a single line.
	//
	// Português:
	//
	// Desenha uma única linha.
	KSvgTextDecorationStyleSolid SvgTextDecorationStyle = "solid"

	// KSvgTextDecorationStyleDouble
	//
	// English:
	//
	// Draws a double line.
	//
	// Português:
	//
	// Desenha uma linha dupla.
	KSvgTextDecorationStyleDouble SvgTextDecorationStyle = "double"

	// KSvgTextDecorationStyleDotted
	//
	// English:
	//
	// Draws a dotted line.
	//
	// Português:
	//
	// Desenha uma linha pontilhada.
	KSvgTextDecorationStyleDotted SvgTextDecorationStyle = "dotted"

	// KSvgTextDecorationStyleDashed
	//
	// English:
	//
	// Draws a dashed line.
	//
	// Português:
	//
	// Desenha uma linha tracejada.
	KSvgTextDecorationStyleDashed SvgTextDecorationStyle = "dashed"

	// KSvgTextDecorationStyleWavy
	//
	// English:
	//
	// Draws a wavy line.
	//
	// Português:
	//
	// Desenha uma linha ondulada.
	KSvgTextDecorationStyleWavy SvgTextDecorationStyle = "wavy"
)

func (SvgTextDecorationStyle) String 

func (e SvgTextDecorationStyle) String() string

type SvgTextRendering 

type SvgTextRendering string
const (
	// KSvgTextRenderingAuto
	//
	// English:
	//
	// This value indicates that the user agent shall make appropriate tradeoffs to balance speed, legibility and
	// geometric precision, but with legibility given more importance than speed and geometric precision.
	//
	// Português:
	//
	// Este valor indica que o agente do usuário deve fazer compensações apropriadas para equilibrar velocidade,
	// legibilidade e precisão geométrica, mas com legibilidade dada mais importância do que velocidade e precisão
	// geométrica.
	KSvgTextRenderingAuto SvgTextRendering = "auto"

	// KSvgTextRenderingOptimizeSpeed
	//
	// English:
	//
	// This value indicates that the user agent shall emphasize rendering speed over legibility and geometric precision.
	// This option will sometimes cause some user agents to turn off text anti-aliasing.
	//
	// Português:
	//
	// Esse valor indica que o agente do usuário deve enfatizar a velocidade de renderização sobre a legibilidade e a
	// precisão geométrica.
	// Essa opção às vezes fará com que alguns agentes do usuário desativem a suavização de serrilhado de texto.
	KSvgTextRenderingOptimizeSpeed SvgTextRendering = "optimizeSpeed"

	// KSvgTextRenderingOptimizeLegibility
	//
	// English:
	//
	// This value indicates that the user agent shall emphasize legibility over rendering speed and geometric precision.
	// The user agent will often choose whether to apply anti-aliasing techniques, built-in font hinting or both to
	// produce the most legible text.
	//
	// Português:
	//
	// Esse valor indica que o agente do usuário deve enfatizar a legibilidade sobre a velocidade de renderização e a
	// precisão geométrica.
	// O agente do usuário geralmente escolherá aplicar técnicas de anti-aliasing, dicas de fonte incorporadas ou ambos
	// para produzir o texto mais legível.
	KSvgTextRenderingOptimizeLegibility SvgTextRendering = "optimizeLegibility"

	// KSvgTextRenderingGeometricPrecision
	//
	// English:
	//
	// This value indicates that the user agent shall emphasize geometric precision over legibility and rendering speed.
	// This option will usually cause the user agent to suspend the use of hinting so that glyph outlines are drawn with
	// comparable geometric precision to the rendering of path data.
	//
	// Português:
	//
	// Esse valor indica que o agente do usuário deve enfatizar a precisão geométrica sobre a legibilidade e a velocidade
	// de renderização.
	// Essa opção geralmente fará com que o agente do usuário suspenda o uso de dicas para que os contornos dos glifos
	// sejam desenhados com precisão geométrica comparável à renderização dos dados do caminho.
	KSvgTextRenderingGeometricPrecision SvgTextRendering = "geometricPrecision"
)

func (SvgTextRendering) String 

func (e SvgTextRendering) String() string

type SvgTransformOrigin 

type SvgTransformOrigin string
const (
	KSvgTransformOriginLeft   SvgTransformOrigin = "left"
	KSvgTransformOriginCenter SvgTransformOrigin = "center"
	KSvgTransformOriginRight  SvgTransformOrigin = "right"
	KSvgTransformOriginTop    SvgTransformOrigin = "top"
	KSvgTransformOriginBottom SvgTransformOrigin = "bottom"
)

func (SvgTransformOrigin) String 

func (e SvgTransformOrigin) String() string

type SvgTypeFeColorMatrix 

type SvgTypeFeColorMatrix string
const (
	KSvgTypeFeColorMatrixMatrix           SvgTypeFeColorMatrix = "matrix"
	KSvgTypeFeColorMatrixSaturate         SvgTypeFeColorMatrix = "saturate"
	KSvgTypeFeColorMatrixHueRotate        SvgTypeFeColorMatrix = "hueRotate"
	KSvgTypeFeColorMatrixLuminanceToAlpha SvgTypeFeColorMatrix = "luminanceToAlpha"
)

func (SvgTypeFeColorMatrix) String 

func (e SvgTypeFeColorMatrix) String() string

type SvgTypeFeFunc 

type SvgTypeFeFunc string
const (
	KSvgTypeFeFuncIdentity SvgTypeFeFunc = "identity"
	KSvgTypeFeFuncTable    SvgTypeFeFunc = "table"
	KSvgTypeFeFuncDiscrete SvgTypeFeFunc = "discrete"
	KSvgTypeFeFuncLinear   SvgTypeFeFunc = "linear"
	KSvgTypeFeFuncGamma    SvgTypeFeFunc = "gamma"
)

func (SvgTypeFeFunc) String 

func (e SvgTypeFeFunc) String() string

type SvgTypeTransform 

type SvgTypeTransform string
const (
	KSvgTypeTransformTranslate SvgTypeTransform = "translate"
	KSvgTypeTransformScale     SvgTypeTransform = "scale"
	KSvgTypeTransformRotate    SvgTypeTransform = "rotate"
	KSvgTypeTransformSkewX     SvgTypeTransform = "skewX"
	KSvgTypeTransformSkewY     SvgTypeTransform = "skewY"
)

func (SvgTypeTransform) String 

func (e SvgTypeTransform) String() string

type SvgTypeTurbulence 

type SvgTypeTurbulence string
const (
	KSvgTypeTurbulenceFractalNoise SvgTypeTurbulence = "fractalNoise"
	KSvgTypeTurbulenceTurbulence   SvgTypeTurbulence = "turbulence"
)

func (SvgTypeTurbulence) String 

func (e SvgTypeTurbulence) String() string

type SvgUnicodeBidi 

type SvgUnicodeBidi string
const (
	KSvgUnicodeBidiNormal          SvgUnicodeBidi = "normal"
	KSvgUnicodeBidiEmbed           SvgUnicodeBidi = "embed"
	KSvgUnicodeBidiIsolate         SvgUnicodeBidi = "isolate"
	KSvgUnicodeBidiBidiOverride    SvgUnicodeBidi = "bidi-override"
	KSvgUnicodeBidiIsolateOverride SvgUnicodeBidi = "isolate-override"
	KSvgUnicodeBidiPlaintext       SvgUnicodeBidi = "plaintext"
)

func (SvgUnicodeBidi) String 

func (e SvgUnicodeBidi) String() string

type SvgUnits 

type SvgUnits string
const (
	// KSvgUnitsUserSpaceOnUse
	//
	// English:
	//
	// This value indicates that all coordinates for the geometry properties refer to the user coordinate system as
	// defined when the pattern was applied.
	//
	// Português:
	//
	// Este valor indica que todas as coordenadas para as propriedades de geometria referem-se ao sistema de coordenadas
	// do usuário conforme definido quando o padrão foi aplicado.
	KSvgUnitsUserSpaceOnUse SvgUnits = "userSpaceOnUse"

	// KSvgUnitsObjectBoundingBox
	//
	// English:
	//
	// This value indicates that all coordinates for the geometry properties represent fractions or percentages of the
	// bounding box of the element to which the pattern is applied. A bounding box could be considered the same as if the
	// content of the <pattern> were bound to a "0 0 1 1" viewbox.
	//
	// Português:
	//
	// Este valor indica que todas as coordenadas das propriedades geométricas representam frações ou porcentagens da
	// caixa delimitadora do elemento ao qual o padrão é aplicado. Uma caixa delimitadora pode ser considerada como se o
	// conteúdo do <pattern> estivesse vinculado a uma caixa de visualização "0 0 1 1".
	KSvgUnitsObjectBoundingBox SvgUnits = "objectBoundingBox"
)

func (SvgUnits) String 

func (e SvgUnits) String() string

type SvgVectorEffect 

type SvgVectorEffect string
const (
	// KSvgVectorEffectNone
	//
	// English:
	//
	// This value specifies that no vector effect shall be applied, i.e. the default rendering behavior is used which is
	// to first fill the geometry of a shape with a specified paint, then stroke the outline with a specified paint.
	//
	// Português:
	//
	// Este valor especifica que nenhum efeito vetorial deve ser aplicado, ou seja, o comportamento de renderização padrão
	// é usado, que é primeiro preencher a geometria de uma forma com uma tinta especificada e, em seguida, traçar o
	// contorno com uma tinta especificada.
	KSvgVectorEffectNone SvgVectorEffect = "none"

	// KSvgVectorEffectNonScalingStroke
	//
	// English:
	//
	// This value modifies the way an object is stroked. Normally stroking involves calculating stroke outline of the
	// shape's path in current user coordinate system and filling that outline with the stroke paint (color or gradient).
	// The resulting visual effect of this value is that the stroke width is not dependent on the transformations of the
	// element (including non-uniform scaling and shear transformations) and zoom level.
	//
	// Português:
	//
	// Esse valor modifica a maneira como um objeto é traçado. Normalmente, o traçado envolve o cálculo do contorno do
	// traçado do caminho da forma no sistema de coordenadas do usuário atual e o preenchimento desse contorno com a
	// pintura do traçado (cor ou gradiente).
	// O efeito visual resultante desse valor é que a largura do traço não depende das transformações do elemento
	// (incluindo escala não uniforme e transformações de cisalhamento) e do nível de zoom.
	KSvgVectorEffectNonScalingStroke SvgVectorEffect = "non-scaling-stroke"

	// KSvgVectorEffectNonScalingSize
	//
	// English:
	//
	// This value specifies a special user coordinate system used by the element and its descendants.
	// The scale of that user coordinate system does not change in spite of any transformation changes from a host
	// coordinate space.
	// However, it does not specify the suppression of rotation and skew. Also, it does not specify the origin of the user
	// coordinate system. Since this value suppresses scaling of the user coordinate system, it also has the
	// characteristics of non-scaling-stroke.
	//
	// Português:
	//
	// Este valor especifica um sistema de coordenadas do usuário especial usado pelo elemento e seus descendentes.
	// A escala desse sistema de coordenadas do usuário não muda apesar de qualquer mudança de transformação de um espaço
	// de coordenadas do hospedeiro. No entanto, não especifica a supressão de rotação e inclinação.
	// Além disso, não especifica a origem do sistema de coordenadas do usuário. Como este valor suprime a escala do
	// sistema de coordenadas do usuário, ele também possui as características de curso sem escala.
	KSvgVectorEffectNonScalingSize SvgVectorEffect = "non-scaling-size"

	// KSvgVectorEffectNonRotation
	//
	// English:
	//
	// This value specifies a special user coordinate system used by the element and its descendants.
	// The rotation and skew of that user coordinate system is suppressed in spite of any transformation changes from a
	// host coordinate space. However, it does not specify the suppression of scaling. Also, it does not specify the
	// origin of user coordinate system.
	//
	// Português:
	//
	// Este valor especifica um sistema de coordenadas do usuário especial usado pelo elemento e seus descendentes.
	// A rotação e a inclinação desse sistema de coordenadas do usuário são suprimidas apesar de quaisquer alterações de
	// transformação de um espaço de coordenadas do host. No entanto, ele não especifica a supressão de dimensionamento.
	// Além disso, não especifica a origem do sistema de coordenadas do usuário.
	KSvgVectorEffectNonRotation SvgVectorEffect = "non-rotation"

	// KSvgVectorEffectFixedPosition
	//
	// English:
	//
	// This value specifies a special user coordinate system used by the element and its descendants. The position of user
	// coordinate system is fixed in spite of any transformation changes from a host coordinate space.
	// However, it does not specify the suppression of rotation, skew and scaling. When this vector effect and the
	// transform property are defined at the same time, that property is consumed for this effect.
	//
	// Português:
	//
	// Este valor especifica um sistema de coordenadas do usuário especial usado pelo elemento e seus descendentes.
	// A posição do sistema de coordenadas do usuário é fixa apesar de quaisquer mudanças de transformação de um espaço de
	// coordenadas do hospedeiro. No entanto, não especifica a supressão de rotação, inclinação e dimensionamento.
	// Quando esse efeito vetorial e a propriedade de transformação são definidos ao mesmo tempo, essa propriedade é
	// consumida para esse efeito.
	KSvgVectorEffectFixedPosition SvgVectorEffect = "fixed-position"
)

func (SvgVectorEffect) String 

func (e SvgVectorEffect) String() string

type SvgVisibility 

type SvgVisibility string
const (
	// KSvgVisibilityVisible
	//
	// English:
	//
	// This value indicates that the element will be painted.
	//
	// Português:
	//
	// Este valor indica que o elemento será pintado.
	KSvgVisibilityVisible SvgVisibility = "visible"

	// KSvgVisibilityHidden
	//
	// English:
	//
	// This value indicates that the element will not be painted. Though it is still part of the rendering tree, i.e. it
	// may receive pointer events depending on the pointer-events attribute, may receive focus depending on the tabindex
	// attribute, contributes to bounding box calculations and clipping paths, and does affect text layout.
	//
	// Português:
	//
	// Este valor indica que o elemento não será pintado. Embora ainda faça parte da árvore de renderização, ou seja, pode
	// receber eventos de ponteiro dependendo do atributo pointer-events, pode receber foco dependendo do atributo
	// tabindex, contribui para cálculos de caixa delimitadora e caminhos de recorte e afeta o layout do texto.
	KSvgVisibilityHidden SvgVisibility = "hidden"

	// KSvgVisibilityCollapse
	//
	// English:
	//
	// This value is equal to hidden.
	//
	// Português:
	//
	// Este valor é igual a oculto.
	KSvgVisibilityCollapse SvgVisibility = "collapse"
)

func (SvgVisibility) String 

func (e SvgVisibility) String() string

type SvgWritingMode 

type SvgWritingMode string
const (
	// KSvgWritingModeHorizontalTb
	//
	// English:
	//
	// This value defines a top-to-bottom block flow direction. Both the writing mode and the typographic mode are
	// horizontal.
	//
	// Português:
	//
	// Este valor define uma direção de fluxo de bloco de cima para baixo. Tanto o modo de escrita quanto o modo
	// tipográfico são horizontais.
	KSvgWritingModeHorizontalTb SvgWritingMode = "horizontal-tb"

	// KSvgWritingModeVerticalRl
	//
	// English:
	//
	// This value defines a right-to-left block flow direction. Both the writing mode and the typographic mode are
	// vertical.
	//
	// Português:
	//
	// Este valor define uma direção de fluxo de bloco da direita para a esquerda. Tanto o modo de escrita quanto o modo
	// tipográfico são verticais.
	KSvgWritingModeVerticalRl SvgWritingMode = "vertical-rl"

	// KSvgWritingModeVerticalLr
	//
	// English:
	//
	// This value defines a left-to-right block flow direction. Both the writing mode and the typographic mode are
	// vertical.
	//
	// Português:
	//
	// Este valor define uma direção de fluxo de bloco da esquerda para a direita. Tanto o modo de escrita quanto o modo
	// tipográfico são verticais.
	KSvgWritingModeVerticalLr SvgWritingMode = "vertical-lr"
)

func (SvgWritingMode) String 

func (e SvgWritingMode) String() string

type Tag 

type Tag string
const (
	// KTagA
	//
	// English:
	//
	//  The Anchor element.
	//
	// The <a> HTML element (or anchor element), with its href attribute, creates a hyperlink to web
	// pages, files, email addresses, locations in the same page, or anything else a URL can address.
	//
	// Content within each <a> should indicate the link's destination. If the href attribute is present,
	// pressing the enter key while focused on the <a> element will activate it.
	//
	// Português:
	//
	//  O elemento Âncora.
	//
	// O elemento HTML <a> (ou elemento âncora), com seu atributo href, cria um hiperlink para páginas
	// da web, arquivos, endereços de e-mail, locais na mesma página ou qualquer outra coisa que um URL
	// possa endereçar.
	//
	// O conteúdo de cada <a> deve indicar o destino do link. Se o atributo href estiver presente,
	// pressionar a tecla enter enquanto estiver focado no elemento <a> irá ativá-lo.
	KTagA Tag = "a"

	// KTagAbbr
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagAbbr Tag = "abbr"

	// KTagAddress
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagAddress Tag = "address"

	// KTagArea
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagArea Tag = "area"

	// KTagArticle
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagArticle Tag = "article"

	// KTagAside
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagAside Tag = "aside"

	// KTagAudio
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagAudio Tag = "audio"

	// KTagB
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagB Tag = "b"

	// KTagBase
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagBase Tag = "base"

	// KTagBdi
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagBdi Tag = "bdi"

	// KTagBdo
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagBdo Tag = "bdo"

	// KTagBlockquote
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagBlockquote Tag = "blockquote"

	// KTagBody
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagBody Tag = "body"

	// KTagBr
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagBr Tag = "br"

	// KTagButton
	//
	// English:
	//
	//  The <button> HTML element is an interactive element activated by a user with a mouse, keyboard, finger, voice command, or other assistive technology. Once activated, it then performs a programmable action, such as submitting a form or opening a dialog.
	//
	// By default, HTML buttons are presented in a style resembling the platform the user agent runs on, but you can change buttons' appearance with CSS.
	//
	// Português::
	//
	//  O elemento HTML <button> é um elemento interativo ativado por um usuário com mouse, teclado,
	//  dedo, comando de voz ou outra tecnologia assistiva. Uma vez ativado, ele executa uma ação
	//  programável, como enviar um formulário ou abrir uma caixa de diálogo.
	//
	// Por padrão, os botões HTML são apresentados em um estilo semelhante à plataforma na qual o agente
	// do usuário é executado, mas você pode alterar a aparência dos botões com CSS.
	KTagButton Tag = "button"

	// KTagCanvas
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagCanvas Tag = "canvas"

	// KTagCaption
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagCaption Tag = "caption"

	// KTagCite
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagCite Tag = "cite"

	// KTagCode
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagCode Tag = "code"

	// KTagCol
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagCol Tag = "col"

	// KTagColgroup
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagColgroup Tag = "colgroup"

	// KTagData
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagData Tag = "data"

	// KTagDatalist
	//
	// English:
	//
	//  The <datalist> HTML element contains a set of <option> elements that represent the permissible
	//  or recommended options available to choose from within other controls.
	//
	// Português:
	//
	//  O elemento HTML <datalist> contém um conjunto de elementos <option> que representam as opções
	//  permitidas ou recomendadas disponíveis para escolha em outros controles.
	KTagDatalist Tag = "datalist"

	// KTagDd
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagDd Tag = "dd"

	// KTagDel
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagDel Tag = "del"

	// KTagDetails
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagDetails Tag = "details"

	// KTagDfn
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagDfn Tag = "dfn"

	// KTagDialog
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagDialog Tag = "dialog"

	// KTagDiv
	//
	//
	// English:
	//
	//  The <div> tag defines a division or a section in an HTML document.
	//
	//   Note:
	//     * By default, browsers always place a line break before and after the <div> element;
	//     * The <div> tag is used as a container for HTML elements - which is then styled with CSS or
	//       manipulated with JavaScript;
	//     * The <div> tag is easily styled by using the class or id attribute;
	//     * Any sort of content can be put inside the <div> tag.
	//
	// Português:
	//
	//  A tag <div> define uma divisão ou uma seção em um documento HTML.
	//
	//   Nota:
	//     * Por padrão, os navegadores sempre colocam uma quebra de linha antes e depois do elemento
	//       <div>;
	//     * A tag <div> é usada como um contêiner para elementos HTML - que são estilizados com CSS ou
	//       manipulados com JavaScript
	//     * A tag <div> é facilmente estilizada usando o atributo class ou id;
	//     * Qualquer tipo de conteúdo pode ser colocado dentro da tag <div>.
	KTagDiv Tag = "div"

	// KTagDl
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagDl Tag = "dl"

	// KTagDt
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagDt Tag = "dt"

	// KTagEm
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagEm Tag = "em"

	// KTagEmbed
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagEmbed Tag = "embed"

	// KTagFieldset
	//
	// English:
	//
	//  The <fieldset> HTML element is used to group several controls as well as labels (<label>)
	//  within a web form.
	//
	// Português:
	//
	//  O elemento HTML <fieldset> é usado para agrupar vários controles, bem como rótulos (<label>)
	//  dentro de um formulário web.
	KTagFieldset Tag = "fieldset"

	// KTagFigcaption
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagFigcaption Tag = "figcaption"

	// KTagFigure
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagFigure Tag = "figure"

	// KTagFooter
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagFooter Tag = "footer"

	// KTagForm
	//
	// English:
	//
	//  The <form> HTML element represents a document section containing interactive controls for
	//  submitting information.
	//
	// Português:
	//
	//  O elemento HTML <form> representa uma seção do documento contendo controles interativos para o
	//  envio de informações.
	KTagForm Tag = "form"

	// KTagHead
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagHead Tag = "head"

	// KTagHeader
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagHeader Tag = "header"

	// KTagH1
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagH1 Tag = "h1"

	// KTagHr
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagHr Tag = "hr"

	// KTagHtml
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagHtml Tag = "html"

	// KTagI
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagI Tag = "i"

	// KTagIframe
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagIframe Tag = "iframe"

	// KTagImg
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagImg Tag = "img"

	// KTagInput
	//
	// English:
	//
	//  The <input> HTML element is used to create interactive controls for web-based forms in order to
	//  accept data from the user; a wide variety of types of input data and control widgets are
	//  available, depending on the device and user agent.
	//
	// The <input> element is one of the most powerful and complex in all of HTML due to the sheer
	// number of combinations of input types and attributes.
	//
	// Português:
	//
	//  O elemento HTML <input> é usado para criar controles interativos para formulários baseados na
	//  web para aceitar dados do usuário; uma ampla variedade de tipos de dados de entrada e widgets
	//  de controle estão disponíveis, dependendo do dispositivo e do agente do usuário.
	//
	// O elemento <input> é um dos mais poderosos e complexos dentro do HTML, devido ao grande número
	// de combinações de tipos de entrada e atributos.
	KTagInput Tag = "input"

	// KTagIns
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagIns Tag = "ins"

	// KTagKbd
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagKbd Tag = "kbd"

	// KTagLabel
	//
	// English:
	//
	//  The <label> HTML element represents a caption for an item in a user interface.
	//
	// Português:
	//
	//  O elemento HTML <label> representa uma legenda para um item em uma interface do usuário.
	KTagLabel Tag = "label"

	// KTagLegend
	//
	// English:
	//
	//  The <legend> HTML element represents a caption for the content of its parent <fieldset>.
	//
	// Português:
	//
	//  O elemento HTML <legend> representa uma legenda para o conteúdo de seu <fieldset> pai.
	KTagLegend Tag = "legend"

	// KTagLi
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagLi Tag = "li"

	// KTagLink
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagLink Tag = "link"

	// KTagMain
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagMain Tag = "main"

	// KTagMap
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagMap Tag = "map"

	// KTagMark
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagMark Tag = "mark"

	// KTagExperimental
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagExperimental Tag = "Experimental"

	// KTagMenu
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagMenu Tag = "menu"

	// KTagMeta
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagMeta Tag = "meta"

	// KTagMeter
	//
	// English:
	//
	//  The <meter> HTML element represents either a scalar value within a known range or a fractional
	//  value.
	//
	// Português:
	//
	//  O elemento HTML <meter> representa um valor escalar dentro de um intervalo conhecido ou um
	//  valor fracionário.
	KTagMeter Tag = "meter"

	// KTagNav
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagNav Tag = "nav"

	// KTagNoscript
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagNoscript Tag = "noscript"

	// KTagObject
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagObject Tag = "object"

	// KTagOl
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagOl Tag = "ol"

	// KTagOptgroup
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagOptgroup Tag = "optgroup"

	// KTagOption
	//
	// English:
	//
	//  The <option> HTML element is used to define an item contained in a <select>, an <optgroup>, or a
	//  <datalist> element. As such, <option> can represent menu items in popups and other lists of
	//  items in an HTML document.
	//
	// Português:
	//
	//  O elemento HTML <option> é usado para definir um item contido em um elemento <select>,
	//  <optgroup> ou <datalist>. Como tal, <option> pode representar itens de menu em pop-ups e outras
	//  listas de itens em um documento HTML.
	KTagOption Tag = "option"

	// KTagOptionGroup
	//
	// English:
	//
	//  The <optgroup> HTML element creates a grouping of options within a <select> element.
	//
	// Português:
	//
	//  O elemento HTML <optgroup> cria um agrupamento de opções dentro de um elemento <select>.
	KTagOptionGroup Tag = "optgroup"

	// KTagOutput
	//
	// English:
	//
	//  The <output> HTML element is a container element into which a site or app can inject the results
	//  of a calculation or the outcome of a user action.
	//
	// Português:
	//
	//  O elemento HTML <output> é um elemento de contêiner no qual um site ou aplicativo pode injetar
	//  os resultados de um cálculo ou o resultado de uma ação do usuário.
	KTagOutput Tag = "output"

	// KTagP
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagP Tag = "p"

	// KTagParam
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagParam Tag = "param"

	// KTagPicture
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagPicture Tag = "picture"

	// KTagPortal
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagPortal Tag = "portal"

	// KTagPre
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagPre Tag = "pre"

	// KTagProgress
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagProgress Tag = "progress"

	// KTagQ
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagQ Tag = "q"

	// KTagRp
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagRp Tag = "rp"

	// KTagRt
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagRt Tag = "rt"

	// KTagRuby
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagRuby Tag = "ruby"

	// KTagS
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagS Tag = "s"

	// KTagSamp
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagSamp Tag = "samp"

	// KTagScript
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagScript Tag = "script"

	// KTagSection
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagSection Tag = "section"

	// KTagSelect
	//
	// English:
	//
	//  The <select> HTML element represents a control that provides a menu of options.
	//
	// Português:
	//
	//  O elemento HTML <select> representa um controle que fornece um menu de opções.
	KTagSelect Tag = "select"

	//todo: documentar
	KTagSvg                 Tag = "svg"
	KTagSvgRect             Tag = "rect"
	KTagSvgFilter           Tag = "filter"
	KTagSvgFeConvolveMatrix Tag = "feConvolveMatrix"
	KTagSvgImage            Tag = "image"

	// KTagSlot
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagSlot Tag = "slot"

	// KTagSmall
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagSmall Tag = "small"

	// KTagSource
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagSource Tag = "source"

	// KTagSpan
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagSpan Tag = "span"

	// KTagStrong
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagStrong Tag = "strong"

	// KTagStyle
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagStyle Tag = "style"

	// KTagSub
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagSub Tag = "sub"

	// KTagSummary
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagSummary Tag = "summary"

	// KTagSup
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagSup Tag = "sup"

	// KTagTable
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagTable Tag = "table"

	// KTagTbody
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagTbody Tag = "tbody"

	// KTagTd
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagTd Tag = "td"

	// KTagTemplate
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagTemplate Tag = "template"

	// KTagTextarea
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagTextarea Tag = "textarea"

	// KTagTfoot
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagTfoot Tag = "tfoot"

	// KTagTh
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagTh Tag = "th"

	// KTagThead
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagThead Tag = "thead"

	// KTagTime
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagTime Tag = "time"

	// KTagTitle
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagTitle Tag = "title"

	// KTagTr
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagTr Tag = "tr"

	// KTagTrack
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagTrack Tag = "track"

	// KTagU
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagU Tag = "u"

	// KTagUl
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagUl Tag = "ul"

	// KTagVar
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagVar Tag = "var"

	// KTagVideo
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagVideo Tag = "video"

	// KTagWbr
	//
	// English:
	//
	//
	//
	// Português:
	//
	//
	KTagWbr Tag = "wbr"
)

func (Tag) String 

func (e Tag) String() string

type TagA 

type TagA struct {
	// contains filtered or unexported fields
}

TagA

English: 

The Anchor element.

The <a> HTML element (or anchor element), with its href attribute, creates a hyperlink to web pages, files, email addresses, locations in the same page, or anything else a URL can address.

Content within each <a> should indicate the link's destination. If the href attribute is present, pressing the enter key while focused on the <a> element will activate it.

Português: 

O elemento Âncora.

O elemento HTML <a> (ou elemento âncora), com seu atributo href, cria um hiperlink para páginas da web, arquivos, endereços de e-mail, locais na mesma página ou qualquer outra coisa que um URL possa endereçar.

O conteúdo de cada <a> deve indicar o destino do link. Se o atributo href estiver presente, pressionar a tecla enter enquanto estiver focado no elemento <a> irá ativá-lo.

func (*TagA) AccessKey 

func (e *TagA) AccessKey(key string) (ref *TagA)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagA) Append 

func (e *TagA) Append(append interface{}) (ref *TagA)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagA) AppendById 

func (e *TagA) AppendById(appendId string) (ref *TagA)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagA) Autofocus 

func (e *TagA) Autofocus(autofocus bool) (ref *TagA)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagA) Class 

func (e *TagA) Class(class ...string) (ref *TagA)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagA) ContentEditable 

func (e *TagA) ContentEditable(editable bool) (ref *TagA)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagA) CreateElement 

func (e *TagA) CreateElement(tag Tag) (ref *TagA)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagA) Data 

func (e *TagA) Data(data map[string]string) (ref *TagA)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagA) Dir 

func (e *TagA) Dir(dir Dir) (ref *TagA)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagA) Download 

func (e *TagA) Download(download string) (ref *TagA)

Download

English: 

Causes the browser to treat the linked URL as a download. Can be used with or without a value

 Note:
   * Without a value, the browser will suggest a filename/extension, generated from various
     sources:
       The Content-Disposition HTTP header;
       The final segment in the URL path;
       The media type (from the Content-Type header, the start of a data: URL, or Blob.type for a
       blob: URL).
   * Defining a value suggests it as the filename. / and \ characters are converted to
     underscores (_). Filesystems may forbid other characters in filenames, so browsers will
     adjust the suggested name if necessary;
   * Download only works for same-origin URLs, or the blob: and data: schemes;
   * How browsers treat downloads varies by browser, user settings, and other factors. The user
     may be prompted before a download starts, or the file may be saved automatically, or it may
     open automatically, either in an external application or in the browser itself;
   * If the Content-Disposition header has different information from the download attribute,
     resulting behavior may differ:
       * If the header specifies a filename, it takes priority over a filename specified in the
         download attribute;
       * If the header specifies a disposition of inline, Chrome and Firefox prioritize the
         attribute and treat it as a download. Old Firefox versions (before 82) prioritize the
         header and will display the content inline.

Português: 

Faz com que o navegador trate a URL vinculada como um download. Pode ser usado com ou sem valor

 Nota:
   * Sem um valor, o navegador sugerirá uma extensão de nome de arquivo, gerada a partir de várias
     fontes:
       O cabeçalho HTTP Content-Disposition;
       O segmento final no caminho do URL;
       O tipo de mídia (do cabeçalho Content-Type, o início de um data: URL ou Blob.type para um
       blob: URL).
   * Definir um valor sugere-o como o nome do arquivo. / e \ caracteres são convertidos em
     sublinhados (_). Os sistemas de arquivos podem proibir outros caracteres em nomes de
     arquivos, portanto, os navegadores ajustarão o nome sugerido, se necessário;
   * O download funciona apenas para URLs de mesma origem, ou os esquemas blob: e data: schemes;
   * A forma como os navegadores tratam os downloads varia de acordo com o navegador, as
     configurações do usuário e outros fatores. O usuário pode ser avisado antes do início de um
     download, ou o arquivo pode ser salvo automaticamente, ou pode ser aberto automaticamente,
     seja em um aplicativo externo ou no próprio navegador;
   * Se o cabeçalho Content-Disposition tiver informações diferentes do atributo download, o
     comportamento resultante pode ser diferente:
       * Se o cabeçalho especificar um nome de arquivo, ele terá prioridade sobre um nome de
         arquivo especificado no atributo download;
       * Se o cabeçalho especificar uma disposição de inline, o Chrome e o Firefox priorizarão o
         atributo e o tratarão como um download. Versões antigas do Firefox (antes de 82)
         priorizam o cabeçalho e exibirão o conteúdo inline.

func (*TagA) Draggable 

func (e *TagA) Draggable(draggable Draggable) (ref *TagA)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagA) EnterKeyHint 

func (e *TagA) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagA)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
       editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
       editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

func (*TagA) GetX 

func (e *TagA) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagA) GetXY 

func (e *TagA) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagA) GetY 

func (e *TagA) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagA) HRef 

func (e *TagA) HRef(href string) (ref *TagA)

HRef

English: 

The URL that the hyperlink points to. Links are not restricted to HTTP-based URLs — they can use
any URL scheme supported by browsers:
  * Sections of a page with fragment URLs;
  * Pieces of media files with media fragments;
  * Telephone numbers with tel: URLs;
  * Email addresses with mailto: URLs;
  * While web browsers may not support other URL schemes, web sites can with
    registerProtocolHandler().

Português: 

A URL para a qual o hiperlink aponta. Os links não são restritos a URLs baseados em HTTP — eles
podem usar qualquer esquema de URL suportado pelos navegadores:
  * Seções de uma página com URLs de fragmento;
  * Pedaços de arquivos de mídia com fragmentos de mídia;
  * Números de telefone com tel: URLs;
  * Endereços de e-mail com mailto: URLs;
  * Embora os navegadores da Web possam não suportar outros esquemas de URL, os sites da Web podem
    com registerProtocolHandler().

func (*TagA) HRefLang 

func (e *TagA) HRefLang(hreflang string) (ref *TagA)

HRefLang

English: 

Hints at the human language of the linked URL. No built-in functionality. Allowed values are the
same as the global lang attribute.

Português: 

Dicas para a linguagem humana da URL vinculada. Nenhuma funcionalidade embutida. Os valores
permitidos são os mesmos do atributo lang global.

func (*TagA) Hidden 

func (e *TagA) Hidden() (ref *TagA)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagA) Id 

func (e *TagA) Id(id string) (ref *TagA)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagA) InputMode 

func (e *TagA) InputMode(inputMode InputMode) (ref *TagA)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents.

This allows a browser to display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagA) Is 

func (e *TagA) Is(is string) (ref *TagA)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagA) ItemDrop 

func (e *TagA) ItemDrop(itemprop string) (ref *TagA)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagA) ItemId 

func (e *TagA) ItemId(id string) (ref *TagA)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagA) ItemRef 

func (e *TagA) ItemRef(itemref string) (ref *TagA)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagA) ItemType 

func (e *TagA) ItemType(itemType string) (ref *TagA)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagA) Lang 

func (e *TagA) Lang(language Language) (ref *TagA)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagA) Nonce 

func (e *TagA) Nonce(part ...string) (ref *TagA)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and
style specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem
que o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagA) Ping 

func (e *TagA) Ping(ping ...string) (ref *TagA)

Ping

English: 

A space-separated list of URLs. When the link is followed, the browser will send POST requests
with the body PING to the URLs. Typically for tracking.

Português: 

Uma lista de URLs separados por espaços. Quando o link for seguido, o navegador enviará
solicitações POST com o corpo PING para as URLs. Normalmente para rastreamento.

func (*TagA) ReferrerPolicy 

func (e *TagA) ReferrerPolicy(referrerPolicy ReferrerPolicy) (ref *TagA)

ReferrerPolicy

English: 

How much of the referrer to send when following the link.

 KRefPolicyNoReferrer: The Referer header will not be sent.
 KRefPolicyNoReferrerWhenDowngrade: The Referer header will not be sent to origins without TLS
   (HTTPS).
 KRefPolicyOrigin: The sent referrer will be limited to the origin of the referring page: its
   scheme, host, and port.
 KRefPolicyOriginWhenCrossOrigin: The referrer sent to other origins will be limited to the
   scheme, the host, and the port. Navigations on the same origin will still include the path.
 KRefPolicySameOrigin: A referrer will be sent for same origin, but cross-origin requests will
   contain no referrer information.
 KRefPolicyStrictOrigin: Only send the origin of the document as the referrer when the protocol
   security level stays the same (HTTPS→HTTPS), but don't send it to a less secure destination
   (HTTPS→HTTP).
 KRefPolicyStrictOriginWhenCrossOrigin (default): Send a full URL when performing a same-origin
   request, only send the origin when the protocol security level stays the same (HTTPS→HTTPS),
   and send no header to a less secure destination (HTTPS→HTTP).
 KRefPolicyUnsafeUrl: The referrer will include the origin and the path (but not the fragment,
   password, or username). This value is unsafe, because it leaks origins and paths from
   TLS-protected resources to insecure origins.

 Note:
   * Experimental. Expect behavior to change in the future. (04/2022)

Português: 

Quanto do referenciador enviar ao seguir o link.

 KRefPolicyNoReferrer: O cabeçalho Referer não será enviado.
 KRefPolicyNoReferrerWhenDowngrade: O cabeçalho Referer não será enviado para origens sem
   TLS (HTTPS).
 KRefPolicyOrigin: O referenciador enviado será limitado à origem da página de referência: seu
   esquema, host e porta.
 KRefPolicyOriginWhenCrossOrigin: O referenciador enviado para outras origens será limitado ao
   esquema, ao host e à porta. As navegações na mesma origem ainda incluirão o caminho.
 KRefPolicySameOrigin: Um referenciador será enviado para a mesma origem, mas as solicitações
   de origem cruzada não conterão informações de referenciador.
 KRefPolicyStrictOrigin: Só envie a origem do documento como referenciador quando o nível de
   segurança do protocolo permanecer o mesmo (HTTPS→HTTPS), mas não envie para um destino menos
   seguro (HTTPS→HTTP).
 KRefPolicyStrictOriginWhenCrossOrigin (padrão): Envie uma URL completa ao realizar uma
   solicitação de mesma origem, envie a origem apenas quando o nível de segurança do protocolo
   permanecer o mesmo (HTTPS→HTTPS) e não envie nenhum cabeçalho para um destino menos seguro
   (HTTPS→HTTP).
 KRefPolicyUnsafeUrl: O referenciador incluirá a origem e o caminho (mas não o fragmento, a
   senha ou o nome de usuário). Esse valor não é seguro porque vaza origens e caminhos de
   recursos protegidos por TLS para origens inseguras.

 Note:
   * Experimental. Expect behavior to change in the future. (04/2022)

func (*TagA) Rel 

func (e *TagA) Rel(rel string) (ref *TagA)

Rel

English: 

The relationship of the linked URL as space-separated link types.

Português: 

O relacionamento da URL vinculada como tipos de link separados por espaço.

func (*TagA) SetX 

func (e *TagA) SetX(x int) (ref *TagA)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagA) SetXY 

func (e *TagA) SetXY(x, y int) (ref *TagA)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagA) SetY 

func (e *TagA) SetY(y int) (ref *TagA)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagA) Slot 

func (e *TagA) Slot(slot string) (ref *TagA)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that
slot attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagA) Spellcheck 

func (e *TagA) Spellcheck(spell bool) (ref *TagA)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagA) Style 

func (e *TagA) Style(style string) (ref *TagA)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagA) TabIndex 

func (e *TagA) TabIndex(index int) (ref *TagA)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagA) Target 

func (e *TagA) Target(target Target) (ref *TagA)

Target

English:

Where to display the linked URL, as the name for a browsing context (a tab, window, or <iframe>). The following keywords have special meanings for where to load the URL: 

KTargetSelf: the current browsing context; (Default)
KTargetBlank: usually a new tab, but users can configure browsers to open a new window instead;
KTargetParent: the parent browsing context of the current one. If no parent, behaves as _self;
KTargetTop: the topmost browsing context (the "highest" context that's an ancestor of the current
  one). If no ancestors, behaves as _self.

Note:
  * Setting target="_blank" on <a> elements implicitly provides the same rel behavior as setting
    rel="noopener" which does not set window.opener. See browser compatibility for support
    status.

Português:

Onde exibir a URL vinculada, como o nome de um contexto de navegação (uma guia, janela ou <iframe>). As seguintes palavras-chave têm significados especiais para onde carregar o URL: 

KTargetSelf: o contexto de navegação atual; (padrão)
KTargetBlank: geralmente uma nova guia, mas os usuários podem configurar os navegadores para
  abrir uma nova janela;
KTargetParent: o contexto de navegação pai do atual. Se nenhum pai, se comporta como _self;
KTargetTop: o contexto de navegação mais alto (o contexto "mais alto" que é um ancestral do
  atual). Se não houver ancestrais, se comporta como _self.

Nota:
  * Definir target="_blank" em elementos <a> fornece implicitamente o mesmo comportamento rel
    que definir rel="noopener" que não define window.opener. Consulte a compatibilidade do
    navegador para obter o status do suporte.

func (*TagA) Title 

func (e *TagA) Title(title string) (ref *TagA)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagA) Translate 

func (e *TagA) Translate(translate Translate) (ref *TagA)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagA) Type 

func (e *TagA) Type(typeProperty Mime) (ref *TagA)

Type

English:

Hints at the linked URL's format with a MIME type. No built-in functionality.

Português:

Dicas no formato do URL vinculado com um tipo MIME. Nenhuma funcionalidade embutida.

type TagButton 

type TagButton struct {
	// contains filtered or unexported fields
}

TagButton

English: 

The <button> HTML element is an interactive element activated by a user with a mouse, keyboard,
finger, voice command, or other assistive technology. Once activated, it then performs a
programmable action, such as submitting a form or opening a dialog.

By default, HTML buttons are presented in a style resembling the platform the user agent runs on, but you can change buttons' appearance with CSS.

Português: 

O elemento HTML <button> é um elemento interativo ativado por um usuário com mouse, teclado,
dedo, comando de voz ou outra tecnologia assistiva. Uma vez ativado, ele executa uma ação
programável, como enviar um formulário ou abrir uma caixa de diálogo.

Por padrão, os botões HTML são apresentados em um estilo semelhante à plataforma na qual o agente do usuário é executado, mas você pode alterar a aparência dos botões com CSS.

func (*TagButton) AccessKey 

func (e *TagButton) AccessKey(key string) (ref *TagButton)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagButton) Append 

func (e *TagButton) Append(append interface{}) (ref *TagButton)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagButton) AppendById 

func (e *TagButton) AppendById(appendId string) (ref *TagButton)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagButton) Autocomplete 

func (e *TagButton) Autocomplete(autocomplete Autocomplete) (ref *TagButton)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagButton) Autofocus 

func (e *TagButton) Autofocus(autofocus bool) (ref *TagButton)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagButton) ButtonType 

func (e *TagButton) ButtonType(value ButtonType) (ref *TagButton)

ButtonType

English: 

The default behavior of the button.

 Input:
   value: default behavior of the button.
     KButtonTypeSubmit: The button submits the form data to the server. This is the default if
       the attribute is not specified for buttons associated with a <form>, or if the attribute
       is an empty or invalid value.
     KButtonTypeReset:  The button resets all the controls to their initial values, like
       <input type="reset">. (This behavior tends to annoy users.)
     KButtonTypeButton: The button has no default behavior, and does nothing when pressed by
       default. It can have client-side scripts listen to the element's events, which are
       triggered when the events occur.

Português: 

O comportamento padrão do botão. Os valores possíveis são:

 Entrada:
   value: comportamento padrão do botão
     KButtonTypeSubmit: O botão envia os dados do formulário para o servidor. Este é o padrão se
       o atributo não for especificado para botões associados a um <form> ou se o atributo for um
       valor vazio ou inválido.
     KButtonTypeReset:  O botão redefine todos os controles para seus valores iniciais, como
       <input type="reset">. (Esse comportamento tende a incomodar os usuários.)
     KButtonTypeButton: O botão não tem comportamento padrão e não faz nada quando pressionado por
       padrão. Ele pode fazer com que os scripts do lado do cliente escutem os eventos do
       elemento, que são acionados quando os eventos ocorrem.

func (*TagButton) Class 

func (e *TagButton) Class(class ...string) (ref *TagButton)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagButton) ContentEditable 

func (e *TagButton) ContentEditable(editable bool) (ref *TagButton)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagButton) CreateElement 

func (e *TagButton) CreateElement(tag Tag) (ref *TagButton)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagButton) Data 

func (e *TagButton) Data(data map[string]string) (ref *TagButton)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagButton) Dir 

func (e *TagButton) Dir(dir Dir) (ref *TagButton)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagButton) Disabled 

func (e *TagButton) Disabled(disabled bool) (ref *TagButton)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagButton) Draggable 

func (e *TagButton) Draggable(draggable Draggable) (ref *TagButton)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagButton) EnterKeyHint 

func (e *TagButton) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagButton)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagButton) Form 

func (e *TagButton) Form(form string) (ref *TagButton)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagButton) FormEncType 

func (e *TagButton) FormEncType(formenctype FormEncType) (ref *TagButton)

FormEncType

English: 

If the button is a submit button (it's inside/associated with a <form> and doesn't have
type="button"), specifies how to encode the form data that is submitted. Possible values:

 Input:
   formenctype: specifies how to encode the form data

     application/x-www-form-urlencoded: The default if the attribute is not used.
     multipart/form-data: Use to submit <input> elements with their type attributes set to file.
     text/plain: Specified as a debugging aid; shouldn't be used for real form submission.

 Note:
   * If this attribute is specified, it overrides the enctype attribute of the button's form
     owner.

Português: 

Se o botão for um botão de envio (está associado a um <form> e não possui type="button"),
especifica como codificar os dados do formulário que são enviados. Valores possíveis:

 Entrada:
   formenctype: especifica como codificar os dados do formulário

     KFormEncTypeApplication: O padrão se o atributo não for usado.
     KFormEncTypeMultiPart: Use para enviar elementos <input> com seus atributos de tipo definidos
       para arquivo.
     KFormEncTypeText: Especificado como auxiliar de depuração; não deve ser usado para envio de
       formulário real.

 Note:
   * Se este atributo for especificado, ele substituirá o atributo enctype do proprietário do
     formulário do botão.

func (*TagButton) FormMethod 

func (e *TagButton) FormMethod(method FormMethod) (ref *TagButton)

FormMethod

English: 

If the button is a submit button (it's inside/associated with a <form> and doesn't have
type="button"), this attribute specifies the HTTP method used to submit the form.

 Input:
   method: specifies the HTTP method used to submit
     KFormMethodPost: The data from the form are included in the body of the HTTP request when
       sent to the server. Use when the form contains information that shouldn't be public, like
       login credentials.
     KFormMethodGet: The form data are appended to the form's action URL, with a ? as a separator,
       and the resulting URL is sent to the server. Use this method when the form has no side
       effects, like search forms.

 Note:
   * If specified, this attribute overrides the method attribute of the button's form owner.

Português: 

Se o botão for um botão de envio (está associado a um <form> e não possui type="button"),
este atributo especifica o método HTTP usado para enviar o formulário.

 Input:
   method: especifica o método HTTP usado para enviar
     KFormMethodPost: Os dados do formulário são incluídos no corpo da solicitação HTTP quando
       enviados ao servidor. Use quando o formulário contém informações que não devem ser
       públicas, como credenciais de login.
     KFormMethodGet: Os dados do formulário são anexados à URL de ação do formulário, com um ?
       como separador e a URL resultante é enviada ao servidor. Use este método quando o
       formulário não tiver efeitos colaterais, como formulários de pesquisa.

 Nota:
   * Se especificado, este atributo substitui o atributo method do proprietário do formulário do
     botão.

func (*TagButton) FormTarget 

func (e *TagButton) FormTarget(formtarget Target) (ref *TagButton)

FormTarget

English: 

If the button is a submit button, this attribute is an author-defined name or standardized,
underscore-prefixed keyword indicating where to display the response from submitting the form.

This is the name of, or keyword for, a browsing context (a tab, window, or <iframe>).

If this attribute is specified, it overrides the target attribute of the button's form owner. The following keywords have special meanings: 

KTargetSelf: the current browsing context; (Default)
KTargetBlank: usually a new tab, but users can configure browsers to open a new window instead;
KTargetParent: the parent browsing context of the current one. If no parent, behaves as _self;
KTargetTop: the topmost browsing context (the "highest" context that's an ancestor of the current
  one). If no ancestors, behaves as _self.

Português: 

Se o botão for um botão de envio, esse atributo será um nome definido pelo autor ou uma
palavra-chave padronizada com prefixo de sublinhado indicando onde exibir a resposta do envio do
formulário.

Este é o nome ou a palavra-chave de um contexto de navegação (uma guia, janela ou <iframe>). Se este atributo for especificado, ele substituirá o atributo de destino do proprietário do formulário do botão. As seguintes palavras-chave têm significados especiais: 

KTargetSelf: o contexto de navegação atual; (padrão)
KTargetBlank: geralmente uma nova guia, mas os usuários podem configurar os navegadores para
  abrir uma nova janela;
KTargetParent: o contexto de navegação pai do atual. Se nenhum pai, se comporta como _self;
KTargetTop: o contexto de navegação mais alto (o contexto "mais alto" que é um ancestral do
  atual). Se não houver ancestrais, se comporta como _self.

func (*TagButton) FormValidate 

func (e *TagButton) FormValidate(validate bool) (ref *TagButton)

FormValidate

English: 

If the button is a submit button, this Boolean attribute specifies that the form is not to be
validated when it is submitted.

If this attribute is specified, it overrides the novalidate attribute of the button's form owner.

Português: 

Se o botão for um botão de envio, este atributo booleano especifica que o formulário não deve ser
validado quando for enviado.

Se este atributo for especificado, ele substituirá o atributo novalidate do proprietário do formulário do botão.

func (*TagButton) FromAction 

func (e *TagButton) FromAction(action string) (ref *TagButton)

FromAction

English: 

The URL that processes the information submitted by the button. Overrides the action attribute of
the button's form owner. Does nothing if there is no form owner.

 Input:
   action: The URL that processes the form submission. This value can be overridden by a
           formaction attribute on a <button>, <input type="submit">, or <input type="image">
           element. This attribute is ignored when method="dialog" is set.

Português: 

A URL que processa as informações enviadas pelo botão. Substitui o atributo de ação do
proprietário do formulário do botão. Não faz nada se não houver um proprietário de formulário.

 Entrada:
   action: A URL que processa o envio do formulário. Esse valor pode ser substituído por um
           atributo formaction em um elemento <button>, <input type="submit"> ou
           <input type="image">. Este atributo é ignorado quando method="dialog" é definido.

func (*TagButton) GetX 

func (e *TagButton) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagButton) GetXY 

func (e *TagButton) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagButton) GetY 

func (e *TagButton) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagButton) Hidden 

func (e *TagButton) Hidden() (ref *TagButton)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagButton) Id 

func (e *TagButton) Id(id string) (ref *TagButton)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagButton) InputMode 

func (e *TagButton) InputMode(inputMode InputMode) (ref *TagButton)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagButton) Is 

func (e *TagButton) Is(is string) (ref *TagButton)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagButton) ItemDrop 

func (e *TagButton) ItemDrop(itemprop string) (ref *TagButton)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagButton) ItemId 

func (e *TagButton) ItemId(id string) (ref *TagButton)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagButton) ItemRef 

func (e *TagButton) ItemRef(itemref string) (ref *TagButton)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagButton) ItemType 

func (e *TagButton) ItemType(itemType string) (ref *TagButton)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagButton) Lang 

func (e *TagButton) Lang(language Language) (ref *TagButton)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagButton) Name 

func (e *TagButton) Name(name string) (ref *TagButton)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagButton) Nonce 

func (e *TagButton) Nonce(nonce int64) (ref *TagButton)

Nonce

English: 

A cryptographic nonce ("number used once") which can be used by Content Security Policy to
determine whether or not a given fetch will be allowed to proceed.

Português: 

Um nonce criptográfico ("número usado uma vez") que pode ser usado pela Política de Segurança de
Conteúdo para determinar se uma determinada busca terá permissão para prosseguir.

func (*TagButton) SetX 

func (e *TagButton) SetX(x int) (ref *TagButton)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagButton) SetXY 

func (e *TagButton) SetXY(x, y int) (ref *TagButton)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagButton) SetY 

func (e *TagButton) SetY(y int) (ref *TagButton)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagButton) Slot 

func (e *TagButton) Slot(slot string) (ref *TagButton)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagButton) Spellcheck 

func (e *TagButton) Spellcheck(spell bool) (ref *TagButton)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagButton) Style 

func (e *TagButton) Style(style string) (ref *TagButton)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagButton) TabIndex 

func (e *TagButton) TabIndex(index int) (ref *TagButton)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagButton) Title 

func (e *TagButton) Title(title string) (ref *TagButton)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagButton) Translate 

func (e *TagButton) Translate(translate Translate) (ref *TagButton)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagButton) Value 

func (e *TagButton) Value(value string) (ref *TagButton)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagCanvas 

type TagCanvas struct {
	// contains filtered or unexported fields
}

func (*TagCanvas) AddColorStopPosition 

func (el *TagCanvas) AddColorStopPosition(stopPosition float64, color color.RGBA) (ref *TagCanvas)

AddColorStopPosition

English: 

Specifies the colors and stop positions in a gradient object

   Input:
     stopPosition: A value between 0.0 and 1.0 that represents the position between start (0%) and
       end (100%) in a gradient;
     color: A color RGBA value to display at the stop position. You can use
       factoryColor.NewColorName() to make it easier;

 Note:
   * Before using this function, you need to generate a gradient with the CreateLinearGradient()
     or CreateRadialGradient() functions;
   * You can call the AddColorStopPosition() method multiple times to change a gradient. If you
     omit this method for gradient objects, the gradient will not be visible. You need to create
     at least one color stop to have a visible gradient.

 Example:

   	var fontA html.Font
   	fontA.Family = factoryFontFamily.NewArial()
   	fontA.Variant = factoryFontVariant.NewSmallCaps()
   	fontA.Style = factoryFontStyle.NewItalic()
   	fontA.Size = 20

   	var fontB html.Font
   	fontB.Family = factoryFontFamily.NewVerdana()
   	fontB.Size = 35

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Font(fontA).
     FillText("Hello World!", 10, 50, 300).
     CreateLinearGradient(0, 0, 160, 0).
     AddColorStopPosition(0.0, factoryColor.NewMagenta()).
     AddColorStopPosition(0.5, factoryColor.NewBlue()).
     AddColorStopPosition(1.0, factoryColor.NewRed()).
     FillStyleGradient().
     Font(fontB).
     FillText("Big smile!", 10, 90, 300).
     AppendToStage()

Português: 

Especifica a cor e a posição final para a cor dentro do gradiente
 Entrada:
   stopPosition: Um valor entre 0.0 e 1.0 que representa a posição entre o início (0%) e o fim
     (100%) dentro do gradiente;
   color: Uma cor no formato RGBA para ser mostrada na posição determinada. Você pode usar
     factoryColor.NewColorName() para facilitar.

 Nota:
   * Antes de usar esta função, você necessita gerar um gradiente com as funções
     CreateLinearGradient() ou CreateRadialGradient();
   * Você pode chamar o método AddColorStopPosition() várias vezes para adicionar várias cores ao
     gradiente, porém, se você omitir o método, o gradiente não será visível. Você tem à obrigação
     de chamar o método pelo menos uma vez com uma cor para que o gradiente seja visível.

 Exemplo:

   	var fontA html.Font
   	fontA.Family = factoryFontFamily.NewArial()
   	fontA.Variant = factoryFontVariant.NewSmallCaps()
   	fontA.Style = factoryFontStyle.NewItalic()
   	fontA.Size = 20

   	var fontB html.Font
   	fontB.Family = factoryFontFamily.NewVerdana()
   	fontB.Size = 35

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Font(fontA).
     FillText("Hello World!", 10, 50, 300).
     CreateLinearGradient(0, 0, 160, 0).
     AddColorStopPosition(0.0, factoryColor.NewMagenta()).
     AddColorStopPosition(0.5, factoryColor.NewBlue()).
     AddColorStopPosition(1.0, factoryColor.NewRed()).
     FillStyleGradient().
     Font(fontB).
     FillText("Big smile!", 10, 90, 300).
     AppendToStage()

func (*TagCanvas) Append 

func (el *TagCanvas) Append(append interface{}) (ref *TagCanvas)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagCanvas) AppendById 

func (el *TagCanvas) AppendById(appendId string) (ref *TagCanvas)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagCanvas) AppendToStage 

func (el *TagCanvas) AppendToStage() (ref *TagCanvas)

func (*TagCanvas) Arc 

func (el *TagCanvas) Arc(x, y int, radius, startAngle, endAngle float64, anticlockwise bool) (ref *TagCanvas)

Arc

English: 

Creates an arc/curve (used to create circles, or parts of circles).

 Input:
   x: The horizontal coordinate of the arc's center;
   y: The vertical coordinate of the arc's center;
   radius: The arc's radius. Must be positive;
   startAngle: The angle at which the arc starts in radians, measured from the positive x-axis;
   endAngle: The angle at which the arc ends in radians, measured from the positive x-axis;
   anticlockwise: An optional Boolean. If true, draws the arc counter-clockwise between the start
     and end angles. The default is false (clockwise).

   Example:

     factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
       BeginPath().
       Arc(100, 75, 50, 0, 2 * math.Pi, false).
       Stroke().
       AppendToStage()

Português: 

Creates an arc/curve (used to create circles, or parts of circles).

 Input:
   x: A coordenada horizontal do centro do arco;
   y: A coordenada vertical do centro do arco;
   radius: O raio do arco. Deve ser positivo;
   startAngle: O ângulo no qual o arco começa em radianos, medido a partir do eixo x positivo;
   endAngle: O ângulo no qual o arco termina em radianos, medido a partir do eixo x positivo;
   anticlockwise: Um booleano opcional. Se true, desenha o arco no sentido anti-horário entre os
     ângulos inicial e final. O padrão é false (sentido horário).

   Example:

     factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
       BeginPath().
       Arc(100, 75, 50, 0, 2 * math.Pi, false).
       Stroke().
       AppendToStage()

func (*TagCanvas) ArcTo 

func (el *TagCanvas) ArcTo(x1, y1, x2, y2 int, radius int) (ref *TagCanvas)

ArcTo

English: 

 Creates an arc/curve between two tangents.

  Input:
    x1: The x-axis coordinate of the first control point.
    y1: The y-axis coordinate of the first control point.
    x2: The x-axis coordinate of the second control point.
    y2: The y-axis coordinate of the second control point.
    radius: The arc's radius. Must be non-negative.

  Example:
    factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
      MoveTo(20, 20).
      LineTo(100, 20).
      ArcTo(150, 20, 150, 70, 50).
      LineTo(150, 120).
      Stroke().
		   AppendToStage()

Português: 

 Cria um arco / curva entre duas tangentes.

  Input:
    x1: A coordenada do eixo x do primeiro ponto de controle;
    y1: A coordenada do eixo y do primeiro ponto de controle;
    x2: A coordenada do eixo x do segundo ponto de controle;
    y2: A coordenada do eixo y do segundo ponto de controle;
    radius: O raio do arco. Deve ser não negativo.

  Example:
    factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
      MoveTo(20, 20).
      LineTo(100, 20).
      ArcTo(150, 20, 150, 70, 50).
      LineTo(150, 120).
      Stroke().
		   AppendToStage()

func (*TagCanvas) BeginPath 

func (el *TagCanvas) BeginPath() (ref *TagCanvas)

BeginPath

English: 

	Begins a path, or resets the current path

  Note:
    * Use MoveTo(), LineTo(), QuadricCurveTo(), BezierCurveTo(), ArcTo(), and Arc(), to
       create paths;
    * Use the Stroke() method to actually draw the path on the canvas.

Português: 

Inicia ou reinicializa uma nova rota no desenho

 Nota:
   * Dica: Use MoveTo(), LineTo(), QuadricCurveTo(), BezierCurveTo(), ArcTo(), e Arc(), para
     criar uma nova rota no desenho;
   * Use o método Stroke() para desenhar a rota no elemento canvas.

todo: fazer exemplo

func (*TagCanvas) BezierCurveTo 

func (el *TagCanvas) BezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y int) (ref *TagCanvas)

BezierCurveTo

English: 

Creates a cubic Bézier curve.

 Input:

   cp1x: The x-axis coordinate of the first control point;
   cp1y: The y-axis coordinate of the first control point;
   cp2x: The x-axis coordinate of the second control point;
   cp2y: The y-axis coordinate of the second control point;
   x: The x-axis coordinate of the end point;
   y: The y-axis coordinate of the end point.

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     BeginPath().
     MoveTo(20, 20).
     BezierCurveTo(20, 100, 200, 100, 200, 20).
     Stroke().
     AppendToStage()

Português: 

Cria uma curva de Bézier cúbica.

 Entrada:

   cp1x: A coordenada do eixo x do primeiro ponto de controle;
   cp1y: A coordenada do eixo y do primeiro ponto de controle;
   cp2x: A coordenada do eixo x do segundo ponto de controle;
   cp2y: A coordenada do eixo y do segundo ponto de controle;
   x: A coordenada do eixo x do ponto final;
   y: A coordenada do eixo y do ponto final.

 Exemplo:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     BeginPath().
     MoveTo(20, 20).
     BezierCurveTo(20, 100, 200, 100, 200, 20).
     Stroke().
     AppendToStage()

func (*TagCanvas) ClearRect 

func (el *TagCanvas) ClearRect(x, y, width, height int) (ref *TagCanvas)

ClearRect

English: 

Clears the specified pixels within a given rectangle.
   x: The x-coordinate of the upper-left corner of the rectangle to clear
   y: The y-coordinate of the upper-left corner of the rectangle to clear
   width: The width of the rectangle to clear, in pixels
   height: The height of the rectangle to clear, in pixels

   The ClearRect() method clears the specified pixels within a given rectangle.

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     FillStyle("red").
     FillRect(0, 0, 300, 150).
     ClearRect(20, 20, 100, 50).
     AppendToStage()

Português: 

Limpa os pixels especificados em um determinado retângulo.
   x: A coordenada x do canto superior esquerdo do retângulo para limpar;
   y: A coordenada y do canto superior esquerdo do retângulo para limpar;
   width: A largura do retângulo a ser limpo, em pixels;
   height: A altura do retângulo a ser limpo, em pixels.

   O método ClearRect() limpa os pixels especificados em um determinado retângulo.

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     FillStyle("red").
     FillRect(0, 0, 300, 150).
     ClearRect(20, 20, 100, 50).
     AppendToStage()

func (*TagCanvas) Clip 

func (el *TagCanvas) Clip(x, y int) (ref *TagCanvas)

Clip

English: 

Clips a region of any shape and size from the original canvas.

The Clip() method clips a region of any shape and size from the original canvas. 

Note:
  * Once a region is clipped, all future drawing will be limited to the clipped region (no
    access to other regions on the canvas). You can however save the current canvas region using
    the Save() method before using the Clip() method, and restore it (with the Restore() method)
    any time in the future.

Português: 

Recorta uma região de qualquer forma e tamanho do canvas original.

O método Clip() recorta uma região de qualquer forma e tamanho do canvas original. 

Nota:
  * Uma vez recortada uma região, todos os desenhos futuros serão limitados à região recortada
    (sem acesso a outras regiões do canvas). No entanto, você pode salvar a região do canvas
    atual usando o método Save() antes de usar o método Clip() e restaurá-la, com o método
    Restore(), a qualquer momento no futuro.

todo: fazer exemplo

func (*TagCanvas) ClosePath 

func (el *TagCanvas) ClosePath(x, y int) (ref *TagCanvas)

ClosePath

English: 

Creates a path from the current point back to the starting point.

The ClosePath() method creates a path from the current point back to the starting point. 

Note:
  * Use the Stroke() method to actually draw the path on the canvas;
  * Use the Fill() method to fill the drawing, black is default. Use the FillStyle() function to
    fill with another color/gradient.

Português: 

Cria um caminho do ponto atual de volta ao ponto inicial.

O método ClosePath() cria um caminho do ponto atual de volta ao ponto inicial. 

Nota:
  * Use o método Stroke() para realmente desenhar o caminho no canvas;
  * Use o método Fill() para preencher o desenho, preto é o padrão. Use a função
    FillStyle() para preencher com outra cor / gradiente.

todo: fazer exemplo

func (*TagCanvas) CreateElement 

func (el *TagCanvas) CreateElement(tag Tag, width, height int) (ref *TagCanvas)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagCanvas) CreateLinearGradient 

func (el *TagCanvas) CreateLinearGradient(x0, y0, x1, y1 int) (ref *TagCanvas)

CreateLinearGradient

English: 

Creates a linear gradient.

 Input:
   x0: The x-coordinate of the start point of the gradient;
   y0: The y-coordinate of the start point of the gradient;
   x1: The x-coordinate of the end point of the gradient;
   y1: The y-coordinate of the end point of the gradient.

The CreateLinearGradient() method creates a linear gradient object.

The gradient can be used to fill rectangles, circles, lines, text, etc. 

Note:
  * Use this object as the value to the strokeStyle or fillStyle properties; //todo: rever documentação
  * Use the AddColorStopPosition() method to specify different colors, and where to position the
    colors in the gradient object.

Example:
  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    CreateLinearGradient(0, 0, 170, 0).
    AddColorStopPosition(0.0, factoryColor.NewBlack()).
    AddColorStopPosition(0.5, factoryColor.NewOrangered()).
    AddColorStopPosition(1.0, factoryColor.NewWhite()).
    FillStyleGradient().
    FillRect(20, 20, 150, 100).
    AppendToStage()

Português: 

Cria um gradiente linear.

 Entrada:
   x0: A coordenada x do ponto inicial do gradiente;
   y0: A coordenada y do ponto inicial do gradiente;
   x1: A coordenada x do ponto final do gradiente;
   y1: A coordenada y do ponto final do gradiente.

O método CreateLinearGradient() cria um objeto gradiente linear.

O gradiente pode ser usado para preencher retângulos, círculos, linhas, texto, etc. 

Nota:
  * Use esta objeto como o valor para as propriedades StrokeStyle() ou FillStyle(); //todo: rever documentação
  * Use o método AddColorStopPosition() para especificar cores diferentes e onde posicionar as
    cores no objeto gradiente.

Exemplo:
  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    CreateLinearGradient(0, 0, 170, 0).
    AddColorStopPosition(0.0, factoryColor.NewBlack()).
    AddColorStopPosition(0.5, factoryColor.NewOrangered()).
    AddColorStopPosition(1.0, factoryColor.NewWhite()).
    FillStyleGradient().
    FillRect(20, 20, 150, 100).
    AppendToStage()

func (*TagCanvas) CreatePattern 

func (el *TagCanvas) CreatePattern(image interface{}, repeatRule CanvasRepeatRule) (ref *TagCanvas)

CreatePattern

English: 

Repeats a specified element in the specified direction.

 Input:
   image: Specifies the image, canvas, or video element of the pattern to use
   repeatedElement
   repeatRule: Image repetition rule.
     KRepeatRuleRepeat: (Default) The pattern repeats both horizontally and vertically
     KRepeatRuleRepeatX: The pattern repeats only horizontally
     KRepeatRuleRepeatY: The pattern repeats only vertically
     KRepeatRuleNoRepeat: The pattern will be displayed only once (no repeat)

The CreatePattern() method repeats the specified element in the specified direction. The element can be an image, video, or another <canvas> element. The repeated element can be used to draw/fill rectangles, circles, lines etc. 

Example:

  var img = factoryBrowser.NewTagImage(
    "spacecraft",
    "./small.png",
    29,
    50,
    true,
  )
  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    CreatePattern(img, html.KRepeatRuleRepeat).
    Rect(0, 0, 300, 300).
    FillStylePattern().
    Fill().
    AppendToStage()

Português: 

Repete um elemento especificado na direção especificada.

 Entrada:
   image: Especifica a imagem, tela ou elemento de vídeo do padrão para usar repeatElement;
   repeatRule: Regra de repetição da imagem.
     KRepeatRuleRepeat: (Padrão) O padrão se repete horizontal e verticalmente;
     KRepeatRuleRepeatX: O padrão se repete apenas horizontalmente;
     KRepeatRuleRepeatY: O padrão se repete apenas verticalmente;
     KRepeatRuleNoRepeat: O padrão será exibido apenas uma vez (sem repetição).

O método CreatePattern() repete o elemento especificado na direção especificada.

O elemento pode ser uma imagem, vídeo ou outro elemento <canvas>.

O elemento repetido pode ser usado para desenhar retângulos, círculos, linhas etc. 

Exemplo:

  var img = factoryBrowser.NewTagImage(
    "spacecraft",
    "./small.png",
    29,
    50,
    true,
  )
  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    CreatePattern(img, html.KRepeatRuleRepeat).
    Rect(0, 0, 300, 300).
    FillStylePattern().
    Fill().
    AppendToStage()

func (*TagCanvas) CreateRadialGradient 

func (el *TagCanvas) CreateRadialGradient(x0, y0, r0, x1, y1 int, r1 float64) (ref *TagCanvas)

CreateRadialGradient

English: 

Creates a radial/circular gradient (to use on canvas content)

 Input:
   x0: The x-coordinate of the starting circle of the gradient;
   y0: The y-coordinate of the starting circle of the gradient;
   r0: The radius of the starting circle;
   x1: The x-coordinate of the ending circle of the gradient;
   y1: The y-coordinate of the ending circle of the gradient;
   r1: The radius of the ending circle.

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     CreateRadialGradient(75, 50, 5, 90, 60, 100).
     AddColorStopPosition(0.0, factoryColor.NewRed()).
     AddColorStopPosition(1.0, factoryColor.NewWhite()).
     FillStyleGradient().
     FillRect(10, 10, 150, 100).
     AppendToStage()

Português: 

Cria um gradiente radial/circular (para usar no conteúdo do canvas)

 Entrada:
   x0: A coordenada x do círculo inicial do gradiente;
   y0: A coordenada y do círculo inicial do gradiente;
   r0: O raio do círculo inicial;
   x1: A coordenada x do círculo final do gradiente;
   y1: A coordenada y do círculo final do gradiente;
   r1: O raio do círculo final.

 Exemplo:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     CreateRadialGradient(75, 50, 5, 90, 60, 100).
     AddColorStopPosition(0.0, factoryColor.NewRed()).
     AddColorStopPosition(1.0, factoryColor.NewWhite()).
     FillStyleGradient().
     FillRect(10, 10, 150, 100).
     AppendToStage()

func (*TagCanvas) DrawImage 

func (el *TagCanvas) DrawImage(image interface{}) (ref *TagCanvas)

DrawImage

English: 

Draws a preloaded image on the canvas element.

 Input:
   image: js.Value object with a preloaded image.

Português: 

Desenha uma imagem pre carregada no elemento canvas.

 Entrada:
   image: objeto js.Value com uma imagem pré carregada.

func (*TagCanvas) Fill 

func (el *TagCanvas) Fill() (ref *TagCanvas)

Fill

English: 

Fills the current drawing (path)

 Note:
   * The default color is black.
   * Use the FillStyle() function to fill with another color/gradient.
   * If the path is not closed, the Fill() method will add a line from the last point to the
     startpoint of the path to close the path (like ClosePath()), and then fill the path.

 Example:

   var img = factoryBrowser.NewTagImage(
     "spacecraft",
     "./small.png",
     29,
     50,
     true,
   )
   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     CreatePattern(img, html.KRepeatRuleRepeat).
     Rect(0, 0, 300, 300).
     FillStylePattern().
     Fill().
     AppendToStage()

Português: 

Preenche o desenho atual (caminho)

 Nota:
   * A cor padrão é preto.
   * Use a função FillStyle() para preencher com outro gradiente de cor.
   * Se o caminho não estiver fechado, o método Fill() adicionará uma linha do último ponto ao
     ponto inicial do caminho para fechar o caminho (como ClosePath()) e, em seguida, preencherá
     o caminho.

 Exemplo:

   var img = factoryBrowser.NewTagImage(
     "spacecraft",
     "./small.png",
     29,
     50,
     true,
   )
   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     CreatePattern(img, html.KRepeatRuleRepeat).
     Rect(0, 0, 300, 300).
     FillStylePattern().
     Fill().
     AppendToStage()

func (*TagCanvas) FillRect 

func (el *TagCanvas) FillRect(x, y, width, height int) (ref *TagCanvas)

FillRect

English: 

Draws a "filled" rectangle

 Input:
   x: The x-coordinate of the upper-left corner of the rectangle;
   y: The y-coordinate of the upper-left corner of the rectangle;
   width: The width of the rectangle, in pixels;
   height: The height of the rectangle, in pixels.

The FillRect() method draws a "filled" rectangle. The default color of the fill is black. 

Note:
  * Use the FillStyle() function to set a color, FillStyleGradient() to set a gradient or
    FillStylePattern() to set a pattern used to fill the drawing.

Example:

  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    FillRect(20, 20, 150, 100).
    AppendToStage()

Português: 

Desenha um retângulo "preenchido"

 Entrada:
   x: A coordenada x do canto superior esquerdo do retângulo;
   y: A coordenada y do canto superior esquerdo do retângulo;
   width: A largura do retângulo, em pixels;
   height: A altura do retângulo, em pixels.

O método FillRect() desenha um retângulo "preenchido". A cor padrão do preenchimento é preto. 

Nota:
  * Use a função FillStyle() para definir uma cor, FillStyleGradient() para definir um gradiente
    ou FillStylePattern() para definir um padrão usado para preencher o desenho.

Example:

  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    FillRect(20, 20, 150, 100).
    AppendToStage()

func (*TagCanvas) FillStyle 

func (el *TagCanvas) FillStyle(value interface{}) (ref *TagCanvas)

FillStyle

English: 

Sets the color, gradient, or pattern used to fill the drawing.

 Input:
   value: the color color.RGBA. You can use factoryColor.NewColorName() to make it easier;

 Note:
   * The default color is black.

Português: 

Define a cor, gradiente ou padrão usado para preencher o desenho.

 Entrada:
   value: a cor color.RGBA. Você pode usar factoryColor.NewColorName() para facilitar;

 Nota:
   * A cor padrão é preto.

func (*TagCanvas) FillStyleGradient 

func (el *TagCanvas) FillStyleGradient() (ref *TagCanvas)

FillStyleGradient

English: 

Sets javascript's fillStyle property after using CreateLinearGradient() or CreateRadialGradient()
functions.

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Font(fontA).
     FillText("Hello World!", 10, 50, 300).
     Save().
     CreateLinearGradient(0, 0, 160, 0).
     AddColorStopPosition(0.0, factoryColor.NewMagenta()).
     AddColorStopPosition(0.5, factoryColor.NewBlue()).
     AddColorStopPosition(1.0, factoryColor.NewRed()).
     FillStyleGradient().
     Font(fontB).
     FillText("Big smile!", 10, 90, 300).
     Restore().
     FillText("Same font used before save", 10, 120, 300).
     AppendToStage()

Português: 

Define a propriedade fillStyle do javascript depois de usar as funções CreateLinearGradient() ou
CreateRadialGradient().

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Font(fontA).
     FillText("Hello World!", 10, 50, 300).
     Save().
     CreateLinearGradient(0, 0, 160, 0).
     AddColorStopPosition(0.0, factoryColor.NewMagenta()).
     AddColorStopPosition(0.5, factoryColor.NewBlue()).
     AddColorStopPosition(1.0, factoryColor.NewRed()).
     FillStyleGradient().
     Font(fontB).
     FillText("Big smile!", 10, 90, 300).
     Restore().
     FillText("Same font used before save", 10, 120, 300).
     AppendToStage()

func (*TagCanvas) FillStylePattern 

func (el *TagCanvas) FillStylePattern() (ref *TagCanvas)

FillStylePattern

English: 

Sets the javascript's fillStyle property after using the CreatePattern() function.

 Example

   var img = factoryBrowser.NewTagImage(
     "spacecraft",
     "./small.png",
     29,
     50,
     true,
   )
   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     CreatePattern(img, html.KRepeatRuleRepeat).
     Rect(0, 0, 300, 300).
     FillStylePattern().
     Fill().
     AppendToStage()

Português: 

Define a propriedade fillStyle do javascript após o uso da função CreatePattern().

 Exemplo:

   var img = factoryBrowser.NewTagImage(
     "spacecraft",
     "./small.png",
     29,
     50,
     true,
   )
   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     CreatePattern(img, html.KRepeatRuleRepeat).
     Rect(0, 0, 300, 300).
     FillStylePattern().
     Fill().
     AppendToStage()

func (*TagCanvas) FillText 

func (el *TagCanvas) FillText(text string, x, y, maxWidth int) (ref *TagCanvas)

FillText

English: 

Draws "filled" text on the canvas

 Input:
   text: Specifies the text that will be written on the canvas;
   x: The x coordinate where to start painting the text (relative to the canvas);
   y: The y coordinate where to start painting the text (relative to the canvas);
   maxWidth: Optional. The maximum allowed width of the text, in pixels.

The FillText() method draws filled text on the canvas. 

Note:
  * Use the Font() function to specify font and font size, and use the FillStyle() function to
    render the text in another color/gradient;
  * The default color of the text is black.

Example:
  	var fontA html.Font
  	fontA.Family = factoryFontFamily.NewArial()
  	fontA.Style = factoryFontStyle.NewItalic()
  	fontA.Size = 20

  	var fontB html.Font
  	fontB.Family = factoryFontFamily.NewVerdana()
  	fontB.Size = 35

  	factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
  	  Font(fontA).
  	  FillText("Hello World!", 10, 50, 300).
  	  CreateLinearGradient(0, 0, 160, 0).
  	  AddColorStopPosition(0.0, factoryColor.NewMagenta()).
  	  AddColorStopPosition(0.5, factoryColor.NewBlue()).
  	  AddColorStopPosition(1.0, factoryColor.NewRed()).
  	  FillStyleGradient().
  	  Font(fontB).
  	  FillText("Big smile!", 10, 90, 300).
  	  AppendToStage()

Português: 

Desenha o texto "preenchido" no canvas.

 Entrada:
   text: Especifica o texto que será escrito no canvas;
   x: A coordenada x onde começar a pintar o texto (em relação ao canvas)
   y: A coordenada y onde começar a pintar o texto (em relação ao canvas)
   maxWidth: A largura máxima permitida do texto, em pixels.

O método FillText() desenha texto preenchido no canvas. 

Nota:
  * Use a função Font() para especificar a fonte e o tamanho da fonte e use a função FillStyle()
    para renderizar o texto em outra cor/gradiente;
  * A cor padrão do texto é preto.

Exemplo:
  	var fontA html.Font
  	fontA.Family = factoryFontFamily.NewArial()
  	fontA.Style = factoryFontStyle.NewItalic()
  	fontA.Size = 20

  	var fontB html.Font
  	fontB.Family = factoryFontFamily.NewVerdana()
  	fontB.Size = 35

  	factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
  	  Font(fontA).
  	  FillText("Hello World!", 10, 50, 300).
  	  CreateLinearGradient(0, 0, 160, 0).
  	  AddColorStopPosition(0.0, factoryColor.NewMagenta()).
  	  AddColorStopPosition(0.5, factoryColor.NewBlue()).
  	  AddColorStopPosition(1.0, factoryColor.NewRed()).
  	  FillStyleGradient().
  	  Font(fontB).
  	  FillText("Big smile!", 10, 90, 300).
  	  AppendToStage()

func (*TagCanvas) Font 

func (el *TagCanvas) Font(font Font) (ref *TagCanvas)

Font

English: 

Sets the current font properties for text content.

  Input:
    font-style: Specifies the font style. Use the factory factoryFontStyle.
      E.g.: factoryFontStyle.NewItalic()
    font-variant: Specifies the font variant. Use the factory factoryFontVariant.
      E.g.: factoryFontVariant.NewSmallCaps()
    font-weight: Specifies the font weight. Use the factory factoryFontWeight.
      E.g.: factoryFontWeight.NewBold()
    font-size/line-height: Specifies the font size and the line-height in pixels
    font-family: Specifies the font family. Use the factory factoryFontFamily.
      E.g.: factoryFontFamily.NewArial()
    caption: Use the font captioned controls (like buttons, drop-downs, etc.)
    icon: Use the font used to label icons
    menu: Use the font used in menus (drop-down menus and menu lists)
    message-box: Use the font used in dialog boxes
    small-caption: Use the font used for labeling small controls
    status-bar: Use the fonts used in window status bar

The Font() function sets the current font properties for text content on the canvas.

Default value: 10px sans-serif 

Example:
  	var fontA html.Font
  	fontA.Family = factoryFontFamily.NewArial()
  	fontA.Style = factoryFontStyle.NewItalic()
  	fontA.Size = 20

  	var fontB html.Font
  	fontB.Family = factoryFontFamily.NewVerdana()
  	fontB.Size = 35

  	factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
  	  Font(fontA).
  	  FillText("Hello World!", 10, 50, 300).
  	  CreateLinearGradient(0, 0, 160, 0).
  	  AddColorStopPosition(0.0, factoryColor.NewMagenta()).
  	  AddColorStopPosition(0.5, factoryColor.NewBlue()).
  	  AddColorStopPosition(1.0, factoryColor.NewRed()).
  	  FillStyleGradient().
  	  Font(fontB).
  	  FillText("Big smile!", 10, 90, 300).
  	  AppendToStage()

Português: 

Define as propriedades de fonte atuais para conteúdo de texto.

  Entrada:
    font-style: Especifica o estilo da fonte. Usar a fábrica factoryFontStyle.
      Ex.: factoryFontStyle.NewItalic()
    font-variant: Especifica a variante da fonte. Usar a fábrica factoryFontVariant.
      Ex.: factoryFontVariant.NewSmallCaps()
    font-weight: Especifica o peso da fonte. Usar a fábrica factoryFontWeight.
      Ex.: factoryFontWeight.NewBold()
    font-size/line-height: Especifica o tamanho da fonte e a altura da linha em pixels
    font-family: Especifica a família de fontes. Usar a fábrica factoryFontFamily.
      Ex.: factoryFontFamily.NewArial()
    caption: Use os controles legendados de fonte (como botões, menus suspensos etc.)
    icon: Use a fonte usada para rotular os ícones
    menu: Use a fonte usada nos menus (menus suspensos e listas de menus)
    message-box: Use a fonte usada nas caixas de diálogo
    small-caption: Use a fonte usada para rotular pequenos controles
    status-bar: Use as fontes usadas na barra de status da janela

A função Font() define ou retorna as propriedades de fonte atuais para conteúdo de texto no canvas

A propriedade font usa a mesma sintaxe que a propriedade font CSS.

Valor padrão: 10px sem serifa 

Exemplo:
  	var fontA html.Font
  	fontA.Family = factoryFontFamily.NewArial()
  	fontA.Style = factoryFontStyle.NewItalic()
  	fontA.Size = 20

  	var fontB html.Font
  	fontB.Family = factoryFontFamily.NewVerdana()
  	fontB.Size = 35

  	factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
  	  Font(fontA).
  	  FillText("Hello World!", 10, 50, 300).
  	  CreateLinearGradient(0, 0, 160, 0).
  	  AddColorStopPosition(0.0, factoryColor.NewMagenta()).
  	  AddColorStopPosition(0.5, factoryColor.NewBlue()).
  	  AddColorStopPosition(1.0, factoryColor.NewRed()).
  	  FillStyleGradient().
  	  Font(fontB).
  	  FillText("Big smile!", 10, 90, 300).
  	  AppendToStage()

func (*TagCanvas) GetCollisionData 

func (el *TagCanvas) GetCollisionData() (data [][]bool)

GetCollisionData

English: 

Returns an array (x,y) with a boolean indicating transparency.

The collision map is a quick way to preload data about the coordinates of where there are parts of the image. 

Output:
  data: [x][y]transparent

Português: 

Retorna uma array (x,y) com um booleano indicando transparência.

O mapa de colisão é uma forma rápida de deixar um dado pre carregado sobre as coordenadas de onde há partes da imagem. 

Saída:
  data: [x][y]transparente

todo: fazer exemplo

func (*TagCanvas) GetImageData 

func (el *TagCanvas) GetImageData(x, y, width, height int) (data [][][]uint8)

GetImageData

English: 

Returns an array copy of the image.

 Input:
   x: x position of the image;
   y: y position of the image;
   width: image width;
   height: image height.

 Output:
   data: image in matrix format.
     [x][y][0]: red color value between 0 and 255
     [x][y][1]: green color value between 0 and 255
     [x][y][2]: blue color value between 0 and 255
     [x][y][3]: alpha color value between 0 and 255

Português: 

Retorna uma cópia matricial da imagem.

 Entrada:
   x: Posição x da imagem;
   y: Posição y da imagem;
   width: comprimento da imagem;
   height: altura da imagem.

 Saída:
   data: imagem em formato matricial.
     [x][y][0]: valor da cor vermelha entre 0 e 255
     [x][y][1]: valor da cor verde entre 0 e 255
     [x][y][2]: valor da cor azul entre 0 e 255
     [x][y][3]: valor da cor alpha entre 0 e 255

todo: fazer exemplo

func (*TagCanvas) GlobalAlpha 

func (el *TagCanvas) GlobalAlpha(value float64) (ref *TagCanvas)

GlobalAlpha

English: 

Sets the current alpha or transparency value of the drawing
   value: The transparency value. Must be a number between 0.0 (fully transparent) and 1.0
     (no transparency)

   Default value: 1.0

 Example:
   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     FillStyle(factoryColor.NewRed()).
     FillRect(20, 20, 75, 50).
     GlobalAlpha(0.2).
     FillStyle(factoryColor.NewBlue()).
     FillRect(50, 50, 75, 50).
     FillStyle(factoryColor.NewGreen()).
     FillRect(80, 80, 75, 50).
     AppendToStage()

Português: 

Define o valor alfa ou transparência atual do desenho
   value: O valor da transparência. Deve ser um número entre 0.0 (totalmente transparente) e
     1.0 (sem transparência)

   Valor padrão: 1.0

 Exemplo:
   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     FillStyle(factoryColor.NewRed()).
     FillRect(20, 20, 75, 50).
     GlobalAlpha(0.2).
     FillStyle(factoryColor.NewBlue()).
     FillRect(50, 50, 75, 50).
     FillStyle(factoryColor.NewGreen()).
     FillRect(80, 80, 75, 50).
     AppendToStage()

func (*TagCanvas) GlobalCompositeOperation 

func (el *TagCanvas) GlobalCompositeOperation(value CompositeOperationsRule) (ref *TagCanvas)

GlobalCompositeOperation

English: 

Sets how a new image are drawn onto an existing image

 Input:
   value: how a source (new) image are drawn onto a destination image.

The GlobalCompositeOperation() function sets how a source (new) image are drawn onto a destination (existing) image. 

Note:
  * source image = drawings you are about to place onto the canvas;
  * destination image = drawings that are already placed onto the canvas;
  * Default value: source-over.

Example:

  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    FillStyle(factoryColor.NewRed()).
    FillRect(20, 20, 75, 50).
    GlobalCompositeOperation(html.KCompositeOperationsRuleSourceOver).
    FillStyle(factoryColor.NewBlue()).
    FillRect(50, 50, 75, 50).
    FillStyle(factoryColor.NewRed()).
    FillRect(150, 20, 75, 50).
    GlobalCompositeOperation(html.KCompositeOperationsRuleDestinationOver).
    FillStyle(factoryColor.NewBlue()).
    FillRect(180, 50, 75, 50).
    AppendToStage()

Português: 

Define como uma nova imagem é desenhada em uma imagem existente.

 Entrada:
   value: como uma imagem de origem (nova) é desenhada em uma imagem de destino.

A função GlobalCompositeOperation() define como uma imagem de origem (nova) é desenhada em uma imagem de destino (existente). 

Nota:
  * imagem de origem = desenhos que você está prestes a colocar no canvas;
  * imagem de destino = desenhos que já estão colocados no canvas;
  * Valor padrão: source-over.

Exemplo:

  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    FillStyle(factoryColor.NewRed()).
    FillRect(20, 20, 75, 50).
    GlobalCompositeOperation(html.KCompositeOperationsRuleSourceOver).
    FillStyle(factoryColor.NewBlue()).
    FillRect(50, 50, 75, 50).
    FillStyle(factoryColor.NewRed()).
    FillRect(150, 20, 75, 50).
    GlobalCompositeOperation(html.KCompositeOperationsRuleDestinationOver).
    FillStyle(factoryColor.NewBlue()).
    FillRect(180, 50, 75, 50).
    AppendToStage()

func (*TagCanvas) Height 

func (el *TagCanvas) Height() (height int)

Height

English: 

Returns the height of an ImageData object.

 Output:
   height: returns the height of an ImageData object, in pixels.

Português: 

Retorna a altura de um objeto ImageData.

 Saída:
   height: retorna à altura de um objeto ImageData, em pixels.

func (*TagCanvas) Id 

func (el *TagCanvas) Id(id string) (ref *TagCanvas)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagCanvas) Init 

func (el *TagCanvas) Init() (ref *TagCanvas)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagCanvas) IsPointInPath 

func (el *TagCanvas) IsPointInPath(x, y int, fillRule FillRule) (isPointInPath bool)

IsPointInPath

English: 

Returns true if the specified point is in the current path, otherwise false

 Input:
   x: The x-axis coordinate of the point to check.
   y: The y-axis coordinate of the point to check.
   fillRule: The algorithm by which to determine if a point is inside or outside the path.
        "nonzero": The non-zero winding rule. Default rule.
        "evenodd": The even-odd winding rule.

 Example:

   canvas := factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Rect(20, 20, 150, 100).
     AppendToStage()
     if canvas.IsPointInPath(20, 51, html.KFillRuleNonZero) {
       canvas.Stroke()
     }

Português: 

Retorna true se o ponto especificado estiver no caminho atual, caso contrário, false

 Entrada:
   x: A coordenada do eixo x do ponto a ser verificado.
   y: A coordenada do eixo y do ponto a ser verificado.
   fillRule: O algoritmo pelo qual determinar se um ponto está dentro ou fora do caminho.
        "nonzero": A regra de enrolamento diferente de zero. Regra padrão.
        "evenodd": A regra do enrolamento par-ímpar.

 Exemplo:

   canvas := factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Rect(20, 20, 150, 100).
     AppendToStage()
     if canvas.IsPointInPath(20, 51, html.KFillRuleNonZero) {
       canvas.Stroke()
     }

func (*TagCanvas) LineCap 

func (el *TagCanvas) LineCap(value CapRule) (ref *TagCanvas)

LineCap

English:: 

Sets the style of the end caps for a line

 Input:
   PlatformBasicType: style of the end caps for a line

 Note:
   * The value "round" and "square" make the lines slightly longer.
   * Default value: butt

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     BeginPath().
     LineCap(html.KCapRuleRound).
     LineWidth(5).
     MoveTo(20, 20).
     LineTo(20, 200).
     Stroke().
     AppendToStage()

Português:: 

Define o estilo das terminações de uma linha

 Entrada:
   PlatformBasicType: estilo das tampas de extremidade para uma linha

 Nota:
   * O valor "redondo" e "quadrado" tornam as linhas um pouco mais longas.
   * Valor padrão: butt

 Exemplo:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     BeginPath().
     LineCap(html.KCapRuleRound).
     LineWidth(5).
     MoveTo(20, 20).
     LineTo(20, 200).
     Stroke().
     AppendToStage()

func (*TagCanvas) LineJoin 

func (el *TagCanvas) LineJoin(value JoinRule) (ref *TagCanvas)

LineJoin

English: 

Sets the type of corner created, when two lines meet

 Input:
   PlatformBasicType: type of corner created

The LineJoin() function sets the type of corner created, when two lines meet. 

Note:
  * The KJoinRuleMiter value is affected by the MiterLimit() function.
  * Default value: miter

Example:

  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    BeginPath().
    LineWidth(5).
    LineJoin(html.KJoinRuleRound).
    MoveTo(20, 20).
    LineTo(100, 50).
    LineTo(20, 100).
    Stroke().
    AppendToStage()

Português: 

Define o tipo de canto criado, quando duas linhas se encontram

 Entrada:
   PlatformBasicType: tipo de canto criado

A função LineJoin() define o tipo de canto criado, quando duas linhas se encontram. 

Nota:
  * O valor KJoinRuleMiter é afetado pela função MiterLimit().
  * Valor padrão: miter

Exemplo:

  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    BeginPath().
    LineWidth(5).
    LineJoin(html.KJoinRuleRound).
    MoveTo(20, 20).
    LineTo(100, 50).
    LineTo(20, 100).
    Stroke().
    AppendToStage()

func (*TagCanvas) LineTo 

func (el *TagCanvas) LineTo(x, y int) (ref *TagCanvas)

LineTo

English: 

Adds a new point and creates a line from that point to the last specified point in the canvas

 Input:
   x: The x-coordinate of where to create the line to
   y: The y-coordinate of where to create the line to

 Note:
   * This method does not draw the line.

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     BeginPath().
     LineWidth(5).
     LineJoin(html.KJoinRuleRound).
     MoveTo(20, 20).
     LineTo(100, 50).
     LineTo(20, 100).
     Stroke().
     AppendToStage()

Português: 

Adiciona um novo ponto e cria uma linha desse ponto até o último ponto especificado no canvas

 Entrada:
   x: A coordenada x de onde criar a linha para
   y: A coordenada y de onde criar a linha para

 Nota:
   * Este método não desenha a linha.

 Exemplo:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     BeginPath().
     LineWidth(5).
     LineJoin(html.KJoinRuleRound).
     MoveTo(20, 20).
     LineTo(100, 50).
     LineTo(20, 100).
     Stroke().
     AppendToStage()

func (*TagCanvas) LineWidth 

func (el *TagCanvas) LineWidth(value int) (ref *TagCanvas)

LineWidth

English: 

Sets the current line width
   value: The current line width, in pixels

 Note:
   * Default value: 1

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     BeginPath().
     LineWidth(5).
     LineJoin(html.KJoinRuleRound).
     MoveTo(20, 20).
     LineTo(100, 50).
     LineTo(20, 100).
     Stroke().
     AppendToStage()

Português: 

Define a largura da linha atual
   value: A largura da linha atual, em pixels

 Nota:
   * Valor padrão: 1

 Exemplo:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     BeginPath().
     LineWidth(5).
     LineJoin(html.KJoinRuleRound).
     MoveTo(20, 20).
     LineTo(100, 50).
     LineTo(20, 100).
     Stroke().
     AppendToStage()

func (*TagCanvas) MeasureText 

func (el *TagCanvas) MeasureText(text string) (width int)

MeasureText

English: 

Returns an object that contains the width of the specified text

 Input:
   text: The text to be measured

 Example:

   var font html.Font
     font.Family = factoryFontFamily.NewArial()
     font.Size = 20

   canvas := factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Font(font)
     w := canvas.MeasureText("Hello Word!")
     wText := strconv.FormatInt(int64(w), 10)
     canvas.FillText("width:"+wText, 10, 50, 300).
     AppendToStage()

Português: 

Retorna um objeto que contém a largura do texto especificado

 Entrada:
   text: O texto a ser medido

 Exemplo:

   var font html.Font
     font.Family = factoryFontFamily.NewArial()
     font.Size = 20

   canvas := factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Font(font)
     w := canvas.MeasureText("Hello Word!")
     wText := strconv.FormatInt(int64(w), 10)
     canvas.FillText("width:"+wText, 10, 50, 300).
     AppendToStage()

func (*TagCanvas) MiterLimit 

func (el *TagCanvas) MiterLimit(value int) (ref *TagCanvas)

MiterLimit

English: 

Sets the maximum miter length

 Input:
   value: A positive number that specifies the maximum miter length.

 Note:
   * If the current miter length exceeds the MiterLimit(), the corner will display as
     LineJoin(KJoinRuleBevel);
   * The miter length is the distance between the inner corner and the outer corner where two
     lines meet;
   * Default value: 10

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     LineWidth(10).
     LineJoin(html.KJoinRuleMiter).
     MiterLimit(5).
     MoveTo(20, 20).
     LineTo(50, 27).
     LineTo(20, 34).
     Stroke().
     AppendToStage()

Português: 

Define ou retorna o comprimento máximo da mitra

 Entrada:
   value: Um número positivo que especifica o comprimento máximo da mitra.

 Nota:
   * Se o comprimento da mitra atual exceder o MiterLimit(), o canto será exibido como
     LineJoin(KJoinRuleBevel);
   * O comprimento da mitra é a distância entre o canto interno e o canto externo onde duas
     linhas se encontram;
   * Valor padrão: 10.

 Exemplo:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     LineWidth(10).
     LineJoin(html.KJoinRuleMiter).
     MiterLimit(5).
     MoveTo(20, 20).
     LineTo(50, 27).
     LineTo(20, 34).
     Stroke().
     AppendToStage()

func (*TagCanvas) MoveTo 

func (el *TagCanvas) MoveTo(x, y int) (ref *TagCanvas)

MoveTo

English: 

Moves the path to the specified point in the canvas, without creating a line

 Input:
   x: The x-coordinate of where to move the path to
   y: The y-coordinate of where to move the path to

The MoveTo() function moves the path to the specified point in the canvas, without creating a line. 

Note:
  * Use the stroke() method to actually draw the path on the canvas.

Example:

  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    BeginPath().
    LineWidth(5).
    LineJoin(html.KJoinRuleRound).
    MoveTo(20, 20).
    LineTo(100, 50).
    LineTo(20, 100).
    Stroke().
    AppendToStage()

Português: 

Move o caminho para o ponto especificado no canvas, sem criar uma linha

 Entrada:
   x: A coordenada x de onde mover o caminho para
   y: A coordenada y de onde mover o caminho para

A função MoveTo() move o caminho para o ponto especificado no canvas, sem criar uma linha. 

Nota:
  * Use o método Stroke() para realmente desenhar o caminho no canvas.

Exemplo:

  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    BeginPath().
    LineWidth(5).
    LineJoin(html.KJoinRuleRound).
    MoveTo(20, 20).
    LineTo(100, 50).
    LineTo(20, 100).
    Stroke().
    AppendToStage()

func (*TagCanvas) PutImageData 

func (el *TagCanvas) PutImageData(imgData [][][]uint8, width, height int) (ref *TagCanvas)

PutImageData

English: 

Transform an array of data into an image.

 Input:
   imgData: data array with the new image;
     [x][y][0]: red color value between 0 and 255;
     [x][y][1]: green color value between 0 and 255;
     [x][y][2]: blue color value between 0 and 255;
     [x][y][3]: alpha color value between 0 and 255.
   width: image width;
   height: image height.

Português: 

Transforma uma matrix de dados em uma imagem.

 Entrada:
   imgData: array de dados com o a nova imagem;
     [x][y][0]: valor da cor vermelha entre 0 e 255;
     [x][y][1]: valor da cor verde entre 0 e 255;
     [x][y][2]: valor da cor azul entre 0 e 255;
     [x][y][3]: valor da cor alpha entre 0 e 255.
   width: comprimento da imagem;
   height: altura da imagem.

todo: fazer exemplo

func (*TagCanvas) QuadraticCurveTo 

func (el *TagCanvas) QuadraticCurveTo(cpx, cpy, x, y int) (ref *TagCanvas)

QuadraticCurveTo

English: 

Creates a quadratic Bézier curve.

 Input:
   cpx: The x-axis coordinate of the control point;
   cpy: The y-axis coordinate of the control point;
   x: The x-axis coordinate of the end point;
   y: The y-axis coordinate of the end point.

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     BeginPath().
     MoveTo(20, 20).
     QuadraticCurveTo(20, 100, 200, 20).
     Stroke().
     AppendToStage()

Português: 

Cria uma curva Bézier quadrática.

 Entrada:
   cpx: A coordenada do eixo x do ponto de controle;
   cpy: A coordenada do eixo y do ponto de controle;
   x: A coordenada do eixo x do ponto final;
   y: A coordenada do eixo y do ponto final.

 Exemplo:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     BeginPath().
     MoveTo(20, 20).
     QuadraticCurveTo(20, 100, 200, 20).
     Stroke().
     AppendToStage()

func (*TagCanvas) Rect 

func (el *TagCanvas) Rect(x, y, width, height int) (ref *TagCanvas)

Rect

English: 

Creates a rectangle.

 Input:
   x: The x-coordinate of the upper-left corner of the rectangle;
   y: The y-coordinate of the upper-left corner of the rectangle;
   width: The width of the rectangle, in pixels;
   height: The height of the rectangle, in pixels.

 Note:
   * Use the Stroke() or Fill() functions to actually draw the rectangle on the canvas.

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Rect(20, 20, 150, 100).
     Stroke().
     AppendToStage()

Português: 

Cria um retângulo.

 Entrada:
   x: A coordenada x do canto superior esquerdo do retângulo;
   y: A coordenada y do canto superior esquerdo do retângulo;
   width: A largura do retângulo, em pixels;
   height: A altura do retângulo, em pixels.

 Nota:
   * Use as funções Stroke() ou Fill() para realmente desenhar o retângulo no canvas.

 Exemplo:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Rect(20, 20, 150, 100).
     Stroke().
     AppendToStage()

func (*TagCanvas) Restore 

func (el *TagCanvas) Restore() (ref *TagCanvas)

Restore

English: 

Returns previously saved path state and attributes.

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Font(fontA).
     FillText("Hello World!", 10, 50, 300).
     Save().
     CreateLinearGradient(0, 0, 160, 0).
     AddColorStopPosition(0.0, factoryColor.NewMagenta()).
     AddColorStopPosition(0.5, factoryColor.NewBlue()).
     AddColorStopPosition(1.0, factoryColor.NewRed()).
     FillStyleGradient().
     Font(fontB).
     FillText("Big smile!", 10, 90, 300).
     Restore().
     FillText("Same font used before save", 10, 120, 300).
     AppendToStage()

Português: 

Retorna o estado e os atributos do caminho salvos anteriormente.

 Exemplo:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Font(fontA).
     FillText("Hello World!", 10, 50, 300).
     Save().
     CreateLinearGradient(0, 0, 160, 0).
     AddColorStopPosition(0.0, factoryColor.NewMagenta()).
     AddColorStopPosition(0.5, factoryColor.NewBlue()).
     AddColorStopPosition(1.0, factoryColor.NewRed()).
     FillStyleGradient().
     Font(fontB).
     FillText("Big smile!", 10, 90, 300).
     Restore().
     FillText("Same font used before save", 10, 120, 300).
     AppendToStage()

func (*TagCanvas) Rotate 

func (el *TagCanvas) Rotate(angle float64) (ref *TagCanvas)

Rotate

English: 

Rotates the current drawing

 Input:
   angle: The rotation angle, in radians.

 Note:
   * To calculate from degrees to radians: degrees*math.Pi/180.
     Example: to rotate 5 degrees, specify the following: 5*math.Pi/180.
   * The rotation will only affect drawings made AFTER the rotation is done.

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Rect(50, 20, 150, 100).
     Stroke().
     Rotate(20*math.Pi/180).
     Rect(50, 20, 150, 100).
     Stroke().
     AppendToStage()

Português: 

Gira o desenho atual.

 Entrada:
   angle: O ângulo de rotação, em radianos.

 Nota:
   * Para calcular de graus para radianos: graus*math.Pi/180.
     Exemplo: para girar 5 graus, especifique o seguinte: 5*math.Pi/180.
   * A rotação só afetará os desenhos feitos APÓS a rotação.

 Exemplo:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Rect(50, 20, 150, 100).
     Stroke().
     Rotate(20*math.Pi/180).
     Rect(50, 20, 150, 100).
     Stroke().
     AppendToStage()

func (*TagCanvas) Save 

func (el *TagCanvas) Save() (ref *TagCanvas)

Save

English: 

Saves the state of the current context.

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Font(fontA).
     FillText("Hello World!", 10, 50, 300).
     Save().
     CreateLinearGradient(0, 0, 160, 0).
     AddColorStopPosition(0.0, factoryColor.NewMagenta()).
     AddColorStopPosition(0.5, factoryColor.NewBlue()).
     AddColorStopPosition(1.0, factoryColor.NewRed()).
     FillStyleGradient().
     Font(fontB).
     FillText("Big smile!", 10, 90, 300).
     Restore().
     FillText("Same font used before save", 10, 120, 300).
     AppendToStage()

Português: 

Salva o estado do contexto atual.

Exemplo:

  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    Font(fontA).
    FillText("Hello World!", 10, 50, 300).
    Save().
    CreateLinearGradient(0, 0, 160, 0).
    AddColorStopPosition(0.0, factoryColor.NewMagenta()).
    AddColorStopPosition(0.5, factoryColor.NewBlue()).
    AddColorStopPosition(1.0, factoryColor.NewRed()).
    FillStyleGradient().
    Font(fontB).
    FillText("Big smile!", 10, 90, 300).
    Restore().
    FillText("Same font used before save", 10, 120, 300).
    AppendToStage()

func (*TagCanvas) Scale 

func (el *TagCanvas) Scale(scaleWidth, scaleHeight float64) (ref *TagCanvas)

Scale

English: 

Scales the current drawing bigger or smaller.

 Input:
   scaleWidth: Scales the width of the current drawing (1.0=100%, 0.5=50%, 2.0=200%, etc.)
   scaleHeight: Scales the height of the current drawing (1.0=100%, 0.5=50%, 2.0=200%, etc.)

 Note:
   * If you scale a drawing, all future drawings will also be scaled;
   * The positioning will also be scaled. If you scale(2.0,2.0); drawings will be positioned
     twice as far from the left and top of the canvas as you specify.

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     StrokeRect(5, 5, 25, 15).
     Scale(2.0, 6.0).
     StrokeRect(5, 5, 25, 15).
     AppendToStage()

Português: 

Dimensiona o desenho atual para maior ou menor.

 Entrada:
   scaleWidth: Dimensiona a largura do desenho atual (1.0=100%, 0.5=50%, 2.0=200%, etc.)
   scaleHeight: Dimensiona a altura do desenho atual (1.0=100%, 0.5=50%, 2.0=200%, etc.)

 Nota:
   * Se você dimensionar um desenho, todos os desenhos futuros também serão dimensionados;
   * O posicionamento também será dimensionado. Se você dimensionar (2.0, 2.0); os desenhos serão
     posicionados duas vezes mais distantes da esquerda e do topo do canvas conforme
     você especificar.

 Exemplo:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     StrokeRect(5, 5, 25, 15).
     Scale(2.0, 6.0).
     StrokeRect(5, 5, 25, 15).
     AppendToStage()

func (*TagCanvas) SetTransform 

func (el *TagCanvas) SetTransform(a, b, c, d, e, f float64) (ref *TagCanvas)

SetTransform

English: 

Resets the current transform to the identity matrix.

 Input:
   a: Scales the drawings horizontally;
   b: Skews the drawings horizontally;
   c: Skews the drawings vertically;
   d: Scales the drawings vertically;
   e: Moves the the drawings horizontally;
   f: Moves the the drawings vertically.

 Note:
   * Each object on the canvas has a current transformation matrix.
     The SetTransform() function resets the current transform to the identity matrix, and then
     put transform data on GetLastTransform() function.
     In other words, the SetTransform() function lets you scale, rotate, move, and skew the
     current context.
   * The transformation will only affect drawings made after the SetTransform() function is
     called.
   * You can use the Save() and Restore() functions to archive the original transform parameters.

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     FillStyle(factoryColor.NewYellow()).
     FillRect(50, 50, 250, 100).
     SetTransform(1.0, 0.5, -0.5, 1.0, 30.0, 10.0).
     FillStyle(factoryColor.NewRed()).
     FillRect(50, 50, 250, 100).
     SetTransform(1.0, 0.5, -0.5, 1.0, 30.0, 10.0).
     FillStyle(factoryColor.NewBlue()).
     FillRect(50, 50, 230, 70).
     AppendToStage()

Português: 

Redefine a transformação atual para a matriz de identidade.

 Entrada:
   a: Dimensiona os desenhos horizontalmente;
   b: Inclina os desenhos horizontalmente;
   c: Inclina os desenhos verticalmente;
   d: Dimensiona os desenhos verticalmente;
   e: Move os desenhos horizontalmente;
   f: Move os desenhos verticalmente.

 Nota:
   * Cada objeto no canvas tem uma matriz de transformação atual.
     A função SetTransform() redefine a transformação atual para a matriz de identidade e, em
     seguida, coloca os dados de transformação na função GetLastTransform().
     Em outras palavras, o método SetTransform() permite dimensionar, girar, mover e inclinar o
     contexto atual.
   * A transformação só afetará os desenhos feitos após a chamada da função SetTransform().
   * Você pode usar as funções Save() e Restore() para arquivar os parâmetros de transform
     originais.

 Exemplo:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     FillStyle(factoryColor.NewYellow()).
     FillRect(50, 50, 250, 100).
     SetTransform(1.0, 0.5, -0.5, 1.0, 30.0, 10.0).
     FillStyle(factoryColor.NewRed()).
     FillRect(50, 50, 250, 100).
     SetTransform(1.0, 0.5, -0.5, 1.0, 30.0, 10.0).
     FillStyle(factoryColor.NewBlue()).
     FillRect(50, 50, 230, 70).
     AppendToStage()

func (*TagCanvas) Stroke 

func (el *TagCanvas) Stroke() (ref *TagCanvas)

Stroke

English: 

The Stroke() method actually draws the path you have defined with all those MoveTo() and
LineTo() methods.

The default color is black. 

Note:
  * Use the StrokeStyle() function to draw with another color/gradient.

Example:

factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
  BeginPath().
  Arc(100, 75, 50, 0, 2 * math.Pi, false).
  Stroke().
  AppendToStage()

Português: 

A função Stroke() na verdade desenha o caminho que você definiu com todos os métodos MoveTo()
e LineTo().

A cor padrão é preto. 

Nota:
  * Use a Função StrokeStyle() para desenhar com outra cor/gradiente

Exemplo:

factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
  BeginPath().
  Arc(100, 75, 50, 0, 2 * math.Pi, false).
  Stroke().
  AppendToStage()

func (*TagCanvas) StrokeRect 

func (el *TagCanvas) StrokeRect(x, y, width, height int) (ref *TagCanvas)

StrokeRect

English: 

Draws a rectangle (no fill)

 Input:
   x: The x-coordinate of the upper-left corner of the rectangle;
   y: The y-coordinate of the upper-left corner of the rectangle;
   width: The width of the rectangle, in pixels;
   height: The height of the rectangle, in pixels;

 Note:
   * The default color of the stroke is black;
   * Use the StrokeStyle() function to set a color, CreateRadialGradient(), CreateLinearGradient()
     or CreatePattern() to style the stroke.

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     StrokeRect(5, 5, 25, 15).
     AppendToStage()

Português: 

Desenha um retângulo (sem preencher)

 entrada:
   x: A coordenada x do canto superior esquerdo do retângulo;
   y: A coordenada y do canto superior esquerdo do retângulo;
   width: A largura do retângulo, em pixels;
   height: A altura do retângulo, em pixels;

 Nota:
   * A cor padrão do traço é preto;
   * Use a função StrokeStyle() para definir uma cor, CreateRadialGradient(),
     CreateLinearGradient() ou CreatePattern() para estilizar o traço.

 Exemplo:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     StrokeRect(5, 5, 25, 15).
     AppendToStage()

func (*TagCanvas) StrokeStyle 

func (el *TagCanvas) StrokeStyle(value interface{}) (ref *TagCanvas)

StrokeStyle

English: 

Sets the color, gradient, or pattern used for strokes.

 Input:
   value: The style must be the color name in textual form, such as "red" or "green", or a color.RGBA value.

 Note:
   * The default color is black.

 Example:

   var colorArc color.RGBA
   canvas := factoryBrowser.NewTagCanvas("canvas_0", 800, 600)
   for i := 0.0; i != 6.0; i += 1.0 {
     for j := 0.0; j != 6.0; j += 1.0 {
       colorArc.R = 0
       colorArc.G = uint8(255.0 - 42.5*i)
       colorArc.B = uint8(255.0 - 42.5*j)
       colorArc.A = 255
       canvas.StrokeStyle(colorArc).
         BeginPath().
         Arc(int(12.5+j*25.0), int(12.5+i*25.0), 10.0, 0.0, math.Pi*2.0, true).
         Stroke()
     }
   }
   canvas.AppendToStage()

Português: 

Define a cor, gradiente ou padrão usado para traçados.

 Entrada:
   value: O estilo deve ser o nome da cor na forma textual, como "red" ou "green", ou um valor color.RGBA.

 Note:
   * A cor padrão é preta.

 Exemplo:

   var colorArc color.RGBA
   canvas := factoryBrowser.NewTagCanvas("canvas_0", 800, 600)
   for i := 0.0; i != 6.0; i += 1.0 {
     for j := 0.0; j != 6.0; j += 1.0 {
       colorArc.R = 0
       colorArc.G = uint8(255.0 - 42.5*i)
       colorArc.B = uint8(255.0 - 42.5*j)
       colorArc.A = 255
       canvas.StrokeStyle(colorArc).
         BeginPath().
         Arc(int(12.5+j*25.0), int(12.5+i*25.0), 10.0, 0.0, math.Pi*2.0, true).
         Stroke()
     }
   }
   canvas.AppendToStage()

func (*TagCanvas) StrokeStyleGradient 

func (el *TagCanvas) StrokeStyleGradient() (ref *TagCanvas)

StrokeStyleGradient 

Sets javascript's strokeStyle property after using CreateLinearGradient() or
CreateRadialGradient() functions.

 Example:

   var fontA html.Font
   fontA.Family = factoryFontFamily.NewArial()
   fontA.Style = factoryFontStyle.NewItalic()
   fontA.Size = 20

   var fontB html.Font
   fontB.Family = factoryFontFamily.NewVerdana()
   fontB.Size = 35

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Font(fontA).
     StrokeText("Hello World!", 10, 50, 300).
     CreateLinearGradient(0, 0, 160, 0).
     AddColorStopPosition(0.0, factoryColor.NewMagenta()).
     AddColorStopPosition(0.5, factoryColor.NewBlue()).
     AddColorStopPosition(1.0, factoryColor.NewRed()).
     StrokeStyleGradient().
     Font(fontB).
     StrokeText("Big smile!", 10, 90, 300).
     AppendToStage()

Português: 

Define a propriedade strokeStyle do javascript depois de usar as funções CreateLinearGradient()
ou CreateRadialGradient().

 Exemplo:

   var fontA html.Font
   fontA.Family = factoryFontFamily.NewArial()
   fontA.Style = factoryFontStyle.NewItalic()
   fontA.Size = 20

   var fontB html.Font
   fontB.Family = factoryFontFamily.NewVerdana()
   fontB.Size = 35

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Font(fontA).
     StrokeText("Hello World!", 10, 50, 300).
     CreateLinearGradient(0, 0, 160, 0).
     AddColorStopPosition(0.0, factoryColor.NewMagenta()).
     AddColorStopPosition(0.5, factoryColor.NewBlue()).
     AddColorStopPosition(1.0, factoryColor.NewRed()).
     StrokeStyleGradient().
     Font(fontB).
     StrokeText("Big smile!", 10, 90, 300).
     AppendToStage()

func (*TagCanvas) StrokeText 

func (el *TagCanvas) StrokeText(text string, x, y, maxWidth int) (ref *TagCanvas)

StrokeText

English: 

Draws text on the canvas (no fill)

 Input:
   text: Specifies the text that will be written on the canvas
   x: The x coordinate where to start painting the text (relative to the canvas)
   y: The y coordinate where to start painting the text (relative to the canvas)
   maxWidth: The maximum allowed width of the text, in pixels

 Note:
   * The default color of the text is black.
   * Use the Font() function to specify font and font size, and use the StrokeStyle() function to
     render the text in another color/gradient.

 Example:

   var fontA html.Font
   fontA.Family = factoryFontFamily.NewArial()
   fontA.Style = factoryFontStyle.NewItalic()
   fontA.Size = 20

   var fontB html.Font
   fontB.Family = factoryFontFamily.NewVerdana()
   fontB.Size = 35

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Font(fontA).
     StrokeText("Hello World!", 10, 50, 300).
     CreateLinearGradient(0, 0, 160, 0).
     AddColorStopPosition(0.0, factoryColor.NewMagenta()).
     AddColorStopPosition(0.5, factoryColor.NewBlue()).
     AddColorStopPosition(1.0, factoryColor.NewRed()).
     StrokeStyleGradient().
     Font(fontB).
     StrokeText("Big smile!", 10, 90, 300).
     AppendToStage()

Português: 

Desenha o texto no canvas (sem preenchimento)

 Entrada:
   text: Especifica o texto a ser desenhado no canvas;
   x: A coordenada X de onde iniciar a pintura do texto (relativa ao canvas)
   y: A coordenada Y de onde iniciar a pintura do texto (relativa ao canvas)
   maxWidth: A largura máxima permitida do texto, em pixels.

 Nota:
   * A cor padrão é preto.
   * Use a função Font() para especificar a fonte e o tamanho do texto, e use a função
     StrokeStyle() para renderizar o texto em outra cor/gradiente.

 Exemplo:

   var fontA html.Font
   fontA.Family = factoryFontFamily.NewArial()
   fontA.Style = factoryFontStyle.NewItalic()
   fontA.Size = 20

   var fontB html.Font
   fontB.Family = factoryFontFamily.NewVerdana()
   fontB.Size = 35

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Font(fontA).
     StrokeText("Hello World!", 10, 50, 300).
     CreateLinearGradient(0, 0, 160, 0).
     AddColorStopPosition(0.0, factoryColor.NewMagenta()).
     AddColorStopPosition(0.5, factoryColor.NewBlue()).
     AddColorStopPosition(1.0, factoryColor.NewRed()).
     StrokeStyleGradient().
     Font(fontB).
     StrokeText("Big smile!", 10, 90, 300).
     AppendToStage()

func (*TagCanvas) TextAlign 

func (el *TagCanvas) TextAlign(value FontAlignRule) (ref *TagCanvas)

TextAlign

English: 

Sets the current alignment for text content

 Input:
   value: the anchor point.

Normally, the text will START in the position specified, however, if you set TextAlign(html.KFontAlignRuleRight) and place the text in position 150, it means that the text should END in position 150. 

Note:
  * Use the FillText() or the StrokeText() function to actually draw and position the text on the canvas.
  * Default value: html.KFontAlignRuleStart

Example:

  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    StrokeStyle(factoryColor.NewRed()).
    MoveTo(150, 20).
    LineTo(150, 170).
    Stroke().
    Font(font).
    TextAlign(html.KFontAlignRuleStart).
    FillText("textAlign = start", 150, 60, 400).
    TextAlign(html.KFontAlignRuleEnd).
    FillText("textAlign = end", 150, 80, 400).
    TextAlign(html.KFontAlignRuleEnd).
    FillText("textAlign = end", 150, 80, 400).
    TextAlign(html.KFontAlignRuleLeft).
    FillText("textAlign = left", 150, 100, 400).
    TextAlign(html.KFontAlignRuleCenter).
    FillText("textAlign = center", 150, 120, 400).
    TextAlign(html.KFontAlignRuleRight).
    FillText("textAlign = right", 150, 140, 400).
    AppendToStage()

Português: 

Define o alinhamento atual do texto.

 Entrada:
   value: o ponto da âncora.

Normalmente, o texto COMEÇARÁ na posição especificada, no entanto, se você definir TextAlign(html.KFontAlignRuleRight) e colocar o texto na posição 150, significa que o texto deve TERMINAR na posição 150. 

NotA:
  * Use a função FillText() ou StrokeText() para realmente desenhar e posicionar o texto no
    canvas;
  * Valor padrão: html.KFontAlignRuleStart

Exemplo:

  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    StrokeStyle(factoryColor.NewRed()).
    MoveTo(150, 20).
    LineTo(150, 170).
    Stroke().
    Font(font).
    TextAlign(html.KFontAlignRuleStart).
    FillText("textAlign = start", 150, 60, 400).
    TextAlign(html.KFontAlignRuleEnd).
    FillText("textAlign = end", 150, 80, 400).
    TextAlign(html.KFontAlignRuleEnd).
    FillText("textAlign = end", 150, 80, 400).
    TextAlign(html.KFontAlignRuleLeft).
    FillText("textAlign = left", 150, 100, 400).
    TextAlign(html.KFontAlignRuleCenter).
    FillText("textAlign = center", 150, 120, 400).
    TextAlign(html.KFontAlignRuleRight).
    FillText("textAlign = right", 150, 140, 400).
    AppendToStage()

func (*TagCanvas) TextBaseline 

func (el *TagCanvas) TextBaseline(value TextBaseLineRule) (ref *TagCanvas)

TextBaseline

English: 

Sets the current text baseline used when drawing text.

 Input:
   PlatformBasicType: text baseline used when drawing text.

 Note:
   * The FillText() and StrokeText() functions will use the specified TextBaseline() value when positioning the text on the canvas.
   Default value: alphabetic

 Example:

   var font html.Font
   font.Family = factoryFontFamily.NewArial()
   font.Size = 20

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     StrokeStyle(factoryColor.NewRed()).
     MoveTo(5, 100).
     LineTo(395, 100).
     Stroke().
     Font(font).
     TextBaseline(html.KTextBaseLineRuleTop).
     FillText("Top", 5, 100, 300).
     TextBaseline(html.KTextBaseLineRuleBottom).
     FillText("Bottom", 50, 100, 300).
     TextBaseline(html.KTextBaseLineRuleMiddle).
     FillText("Middle", 120, 100, 300).
     TextBaseline(html.KTextBaseLineRuleAlphabetic).
     FillText("Alphabetic", 190, 100, 300).
     TextBaseline(html.KTextBaseLineRuleHanging).
     FillText("Hanging", 290, 100, 300).
     AppendToStage()

Português: 

Define a linha de base usada para desenhar o texto.

 Entrada:
   PlatformBasicType: linha de base usada para desenhar o texto.

 Nota:
   * As funções FillText() e StrokeText() vão usar a linha de base especificada pela função TextBaseline() antes de posicionar o texto no canvas.
   * Valor padrão: html.KTextBaseLineRuleAlphabetic

 Exemplo:

   var font html.Font
   font.Family = factoryFontFamily.NewArial()
   font.Size = 20

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     StrokeStyle(factoryColor.NewRed()).
     MoveTo(5, 100).
     LineTo(395, 100).
     Stroke().
     Font(font).
     TextBaseline(html.KTextBaseLineRuleTop).
     FillText("Top", 5, 100, 300).
     TextBaseline(html.KTextBaseLineRuleBottom).
     FillText("Bottom", 50, 100, 300).
     TextBaseline(html.KTextBaseLineRuleMiddle).
     FillText("Middle", 120, 100, 300).
     TextBaseline(html.KTextBaseLineRuleAlphabetic).
     FillText("Alphabetic", 190, 100, 300).
     TextBaseline(html.KTextBaseLineRuleHanging).
     FillText("Hanging", 290, 100, 300).
     AppendToStage()

func (*TagCanvas) Transform 

func (el *TagCanvas) Transform(a, b, c, d, e, f float64) (ref *TagCanvas)

Transform

English: 

Replaces the current transformation matrix for the drawing

 Input:
   a: Scales the drawing horizontally;
   b: Skew the the drawing horizontally;
   c: Skew the the drawing vertically;
   d: Scales the drawing vertically;
   e: Moves the the drawing horizontally;
   f: Moves the the drawing vertically.

Each object on the canvas has a current transformation matrix. The Transform() method replaces the current transformation matrix. It multiplies the current transformation matrix with the matrix described by: 

 a | c | e
---+---+---
 b | d | f
---+---+---
 0 | 0 | 1

In other words, the Transform() method lets you scale, rotate, move, and skew the current context. 

Note:
  * The transformation will only affect drawings made after the Transform() method is called;
  * The Transform() function behaves relatively to other transformations made by Rotate(),
    Scale(), Translate(), or Transform().
      Example: If you already have set your drawing to scale by two, and the Transform() method
      scales your drawings by two, your drawings will now scale by four.
  * Check out the SetTransform() method, which does not behave relatively to other
    transformations.
  * You can use the Save() and Restore() functions to archive the original transform parameters.

Example:

  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    FillStyle(factoryColor.NewYellow()).
    FillRect(50, 50, 250, 100).
    Transform(1.0, 0.5, -0.5, 1.0, 30.0, 10.0).
    FillStyle(factoryColor.NewRed()).
    FillRect(50, 50, 250, 100).
    Transform(1.0, 0.5, -0.5, 1.0, 30.0, 10.0).
    FillStyle(factoryColor.NewBlue()).
    FillRect(50, 50, 230, 70).
    AppendToStage()

Português: 

Substitui a matriz de transformação atual para o desenho

 Entrada:
   a: Dimensiona o desenho horizontalmente;
   b: Inclinar o desenho horizontalmente;
   c: Inclinar o desenho verticalmente;
   d: Dimensiona o desenho verticalmente;
   e: Move o desenho horizontalmente;
   f: Move o desenho verticalmente.

Cada objeto no canvas tem uma matriz de transformação atual. O método Transform() substitui a matriz de transformação atual. Ele multiplica a matriz de transformação atual com a matriz descrita por: 

 a | c | e
---+---+---
 b | d | f
---+---+---
 0 | 0 | 1

Em outras palavras, o método Transform() permite dimensionar, girar, mover e inclinar o contexto atual. 

Nota:
  * A transformação só afetará os desenhos feitos depois que o método Transform() for chamado;
  * A função Transform() se comporta relativamente a outras transformações feitas por Rotate(),
    Scale(), Translate() ou Transform().
    Exemplo: Se você já configurou seu desenho para dimensionar em dois, e o método Transform()
      dimensiona seus desenhos em dois, seus desenhos agora serão dimensionados em quatro.
  * Confira o método SetTransform(), que não se comporta em relação a outras transformações.
  * Você pode usar as funções Save() e Restore() para arquivar os parâmetros de transform
    originais.

Exemplo:

  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    FillStyle(factoryColor.NewYellow()).
    FillRect(50, 50, 250, 100).
    Transform(1.0, 0.5, -0.5, 1.0, 30.0, 10.0).
    FillStyle(factoryColor.NewRed()).
    FillRect(50, 50, 250, 100).
    Transform(1.0, 0.5, -0.5, 1.0, 30.0, 10.0).
    FillStyle(factoryColor.NewBlue()).
    FillRect(50, 50, 230, 70).
    AppendToStage()

func (*TagCanvas) Translate 

func (el *TagCanvas) Translate(x, y int) (ref *TagCanvas)

Translate

English: 

Remaps the (0,0) position on the canvas

 Input:
   x: The value to add to horizontal (x) coordinates;
   y: The value to add to vertical (y) coordinates.

 Note:
   * When you call a method like FillRect() after Translate(), the value is added to the x and y
     coordinate values for all new canvas elements.

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     FillRect(10, 10, 100, 50).
     Translate(70, 70).
     FillRect(10, 10, 100, 50).
     AppendToStage()

Português: 

Remapeia a posição (0,0) no canvas

 Entrada:
   x: O valor a ser adicionado às coordenadas horizontais (x);
   y: O valor a ser adicionado às coordenadas verticais (y).

 Nota:
   * Quando você chama um método como FillRect() após Translate(), o valor é adicionado aos
     valores das coordenadas x e y para todos os novos elementos do canvas.

 Exemplo:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     FillRect(10, 10, 100, 50).
     Translate(70, 70).
     FillRect(10, 10, 100, 50).
     AppendToStage()

type TagDataList 

type TagDataList struct {
	// contains filtered or unexported fields
}

TagDataList

English: 

The <datalist> HTML element contains a set of <option> elements that represent the permissible
or recommended options available to choose from within other controls.

Português: 

O elemento HTML <datalist> contém um conjunto de elementos <option> que representam as opções
permitidas ou recomendadas disponíveis para escolha em outros controles.

func (*TagDataList) AccessKey 

func (e *TagDataList) AccessKey(key string) (ref *TagDataList)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagDataList) Append 

func (e *TagDataList) Append(append interface{}) (ref *TagDataList)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagDataList) AppendById 

func (e *TagDataList) AppendById(appendId string) (ref *TagDataList)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagDataList) Autofocus 

func (e *TagDataList) Autofocus(autofocus bool) (ref *TagDataList)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagDataList) Class 

func (e *TagDataList) Class(class ...string) (ref *TagDataList)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

func (*TagDataList) ContentEditable 

func (e *TagDataList) ContentEditable(editable bool) (ref *TagDataList)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagDataList) CreateElement 

func (e *TagDataList) CreateElement(tag Tag) (ref *TagDataList)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagDataList) Data 

func (e *TagDataList) Data(data map[string]string) (ref *TagDataList)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagDataList) Dir 

func (e *TagDataList) Dir(dir Dir) (ref *TagDataList)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagDataList) Draggable 

func (e *TagDataList) Draggable(draggable Draggable) (ref *TagDataList)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagDataList) EnterKeyHint 

func (e *TagDataList) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagDataList)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagDataList) GetX 

func (e *TagDataList) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagDataList) GetXY 

func (e *TagDataList) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagDataList) GetY 

func (e *TagDataList) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagDataList) Hidden 

func (e *TagDataList) Hidden() (ref *TagDataList)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagDataList) Id 

func (e *TagDataList) Id(id string) (ref *TagDataList)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagDataList) InputMode 

func (e *TagDataList) InputMode(inputMode InputMode) (ref *TagDataList)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagDataList) Is 

func (e *TagDataList) Is(is string) (ref *TagDataList)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagDataList) ItemDrop 

func (e *TagDataList) ItemDrop(itemprop string) (ref *TagDataList)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagDataList) ItemId 

func (e *TagDataList) ItemId(id string) (ref *TagDataList)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagDataList) ItemRef 

func (e *TagDataList) ItemRef(itemref string) (ref *TagDataList)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagDataList) ItemType 

func (e *TagDataList) ItemType(itemType string) (ref *TagDataList)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagDataList) Lang 

func (e *TagDataList) Lang(language Language) (ref *TagDataList)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagDataList) NewOption 

func (e *TagDataList) NewOption(id, label, value string, disabled, selected bool) (ref *TagDataList)

NewOption

English: 

The <option> HTML element is used to define an item contained in a <select>, an <optgroup>, or
a <datalist> element. As such, <option> can represent menu items in popups and other lists of
items in an HTML document.

 Input:
   id: a unique id for an element;
   label: This attribute is text for the label indicating the meaning of the option. If the label
     attribute isn't defined, its value is that of the element text content;
   value: The content of this attribute represents the value to be submitted with the form, should
     this option be selected. If this attribute is omitted, the value is taken from the text
     content of the option element;
   disabled: If this Boolean attribute is set, this option is not checkable. Often browsers grey
     out such control and it won't receive any browsing event, like mouse clicks or focus-related
     ones. If this attribute is not set, the element can still be disabled if one of its ancestors
     is a disabled <optgroup> element;
   selected: If present, this Boolean attribute indicates that the option is initially selected.
     If the <option> element is the descendant of a <select> element whose multiple attribute is
     not set, only one single <option> of this <select> element may have the selected attribute.

Português: 

O elemento HTML <option> é usado para definir um item contido em um elemento <select>, <optgroup>
ou <datalist>. Como tal, <option> pode representar itens de menu em pop-ups e outras listas de
itens em um documento HTML.

 Entrada:
   id: um id exclusivo para um elemento;
   label: Este atributo é um texto para o rótulo que indica o significado da opção. Se o atributo
     label não estiver definido, seu valor será o do conteúdo do texto do elemento;
   value: O conteúdo deste atributo representa o valor a ser enviado com o formulário, caso esta
     opção seja selecionada. Se este atributo for omitido, o valor será obtido do conteúdo de
     texto do elemento de opção;
   disabled: Se este atributo booleano estiver definido, esta opção não poderá ser marcada.
     Muitas vezes, os navegadores desativam esse controle e não recebem nenhum evento de
     navegação, como cliques do mouse ou relacionados ao foco. Se este atributo não for definido,
     o elemento ainda poderá ser desabilitado se um de seus ancestrais for um elemento <optgroup>
     desabilitado;
   selected: Se presente, este atributo booleano indica que a opção foi selecionada inicialmente.
     Se o elemento <option> é descendente de um elemento <select> cujo atributo múltiplo não está
     definido, apenas um único <option> deste elemento <select> pode ter o atributo selecionado.

func (*TagDataList) Nonce 

func (e *TagDataList) Nonce(nonce int64) (ref *TagDataList)

Nonce

English: 

A cryptographic nonce ("number used once") which can be used by Content Security Policy to
determine whether or not a given fetch will be allowed to proceed.

Português: 

Um nonce criptográfico ("número usado uma vez") que pode ser usado pela Política de Segurança de
Conteúdo para determinar se uma determinada busca terá permissão para prosseguir.

func (*TagDataList) SetX 

func (e *TagDataList) SetX(x int) (ref *TagDataList)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagDataList) SetXY 

func (e *TagDataList) SetXY(x, y int) (ref *TagDataList)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagDataList) SetY 

func (e *TagDataList) SetY(y int) (ref *TagDataList)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagDataList) Slot 

func (e *TagDataList) Slot(slot string) (ref *TagDataList)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagDataList) Spellcheck 

func (e *TagDataList) Spellcheck(spell bool) (ref *TagDataList)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagDataList) Style 

func (e *TagDataList) Style(style string) (ref *TagDataList)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagDataList) TabIndex 

func (e *TagDataList) TabIndex(index int) (ref *TagDataList)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagDataList) Title 

func (e *TagDataList) Title(title string) (ref *TagDataList)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagDataList) Translate 

func (e *TagDataList) Translate(translate Translate) (ref *TagDataList)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

type TagDiv 

type TagDiv struct {
	// contains filtered or unexported fields
}

TagDiv

English: 

The <div> tag defines a division or a section in an HTML document.

 Note:
   * By default, browsers always place a line break before and after the <div> element;
   * The <div> tag is used as a container for HTML elements - which is then styled with CSS or
     manipulated with JavaScript;
   * The <div> tag is easily styled by using the class or id attribute;
   * Any sort of content can be put inside the <div> tag.

Português: 

A tag <div> define uma divisão ou uma seção em um documento HTML.

 Nota:
   * Por padrão, os navegadores sempre colocam uma quebra de linha antes e depois do elemento
     <div>;
   * A tag <div> é usada como um contêiner para elementos HTML - que são estilizados com CSS ou
     manipulados com JavaScript
   * A tag <div> é facilmente estilizada usando o atributo class ou id;
   * Qualquer tipo de conteúdo pode ser colocado dentro da tag <div>.

func (*TagDiv) AccessKey 

func (e *TagDiv) AccessKey(key string) (ref *TagDiv)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagDiv) AddListener 

func (e *TagDiv) AddListener(eventType interface{}, manager mouse.SimpleManager) (ref *TagDiv)

AddListener

English: 

Associates a function with an event.

 Example:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

Português: 

Associa uma função a um evento.

 Exemplo:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

func (*TagDiv) AddPointsToEasingTween 

func (e *TagDiv) AddPointsToEasingTween(algorithmRef algorithm.CurveInterface) (ref *TagDiv)

AddPointsToEasingTween

English: 

This function returns an easing tween function compatible with the easing onStepFunc() function in order to use the
points generated by the line algorithms as a reference to the movement.

 Note:
   * The 'onStartValue' and 'onEndValue' parameters must have the values 0 and 10000.
     Example:
       factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

Português: 

Esta função retorna uma função easing tween compatível com a função onStepFunc() do easing de modo a usar os pontos
gerados pelos algoritmos de linha como referência ao movimento.

 Nota:
   * O parâmetros 'onStartValue' e 'onEndValue' devem, obrigatoriamente, ter os valores 0 e 10000.
     Exemplo:
       factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

func (*TagDiv) Append 

func (e *TagDiv) Append(elements ...Compatible) (ref *TagDiv)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

fixme: fazer append() assim em todas as tags html, exceto svg

func (*TagDiv) AppendById 

func (e *TagDiv) AppendById(appendId string) (ref *TagDiv)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagDiv) AppendToStage 

func (e *TagDiv) AppendToStage() (ref *TagDiv)

AppendToStage

English: 

Adds a node to the end of the list of children in the main document body. If the node already
exists somewhere in the document, it is removed from its current parent node before being added
to the main document.

Português: 

Adiciona um nó ao final da lista de filhos do corpo do documento principal. Se o nó já existir
em alguma parte do documento, ele é removido de seu nó pai atual antes de ser adicionado ao
documento principal.

todo:https://developer.mozilla.org/en-US/docs/Web/API/Document/createDocumentFragment todo: appendMany()

func (*TagDiv) Autofocus 

func (e *TagDiv) Autofocus(autofocus bool) (ref *TagDiv)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagDiv) Class 

func (e *TagDiv) Class(class ...string) (ref *TagDiv)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagDiv) ContentEditable 

func (e *TagDiv) ContentEditable(editable bool) (ref *TagDiv)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagDiv) CreateElement 

func (e *TagDiv) CreateElement(tag Tag) (ref *TagDiv)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagDiv) Data 

func (e *TagDiv) Data(data map[string]string) (ref *TagDiv)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagDiv) Dir 

func (e *TagDiv) Dir(dir Dir) (ref *TagDiv)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagDiv) DragStart 

func (e *TagDiv) DragStart() (ref *TagDiv)

DragStart

English: 

Mouse drag function.

 Example:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

Português: 

Função de arrastar com o mouse.

 Exemplo:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

func (*TagDiv) DragStop 

func (e *TagDiv) DragStop() (ref *TagDiv)

DragStop

English: 

Stop mouse drag functionality.

 Example:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

   go func() {
     time.Sleep(10 * time.Second)
     div.DragStop()
   }()

Português: 

Para a funcionalidade de arrastar com o mouse.

 Exemplo:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

   go func() {
     time.Sleep(10 * time.Second)
     div.DragStop()
   }()

func (*TagDiv) Draggable 

func (e *TagDiv) Draggable(draggable Draggable) (ref *TagDiv)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagDiv) EasingTweenWalkingAndRotateIntoPoints 

func (e *TagDiv) EasingTweenWalkingAndRotateIntoPoints() (function func(forTenThousand, percent float64, args interface{}))

EasingTweenWalkingAndRotateIntoPoints

English: 

Moves the element on the line added by the AddPointsToEasingTween() function and adjusts the rotation of the
element with respect to the next point.

This function returns a second function compatible with the easing tween's onStepFunc() function. 

Note:
  * Use the RotateDelta() function to adjust the starting angle;
  * The 'onStartValue' and 'onEndValue' parameters must have the values 0 and 10000.
    Example:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

Português: 

Desloca o elemento na linha adicionada pela função AddPointsToEasingTween() e ajusta a rotação do elemento em relação ao próximo ponto.

Esta função retorna uma segunda função compatível com a função onStepFunc() do easing tween. 

Nota:
  * Use a função RotateDelta() para ajustar o ângulo inicial;
  * O parâmetros 'onStartValue' e 'onEndValue' devem, obrigatoriamente, ter os valores 0 e 10000.
    Exemplo:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

func (*TagDiv) EasingTweenWalkingIntoPoints 

func (e *TagDiv) EasingTweenWalkingIntoPoints() (function func(percent, p float64, args interface{}))

EasingTweenWalkingIntoPoints

English: 

Moves the element on the line added by the AddPointsToEasingTween() function.

This function returns a second function compatible with the easing tween's onStepFunc() function. 

Note:
  * The 'onStartValue' and 'onEndValue' parameters must have the values 0 and 10000.
    Example:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

Português: 

Desloca o elemento na linha adicionada pela função AddPointsToEasingTween().

Esta função retorna uma segunda função compatível com a função onStepFunc() do easing tween. 

Nota:
  * O parâmetros 'onStartValue' e 'onEndValue' devem, obrigatoriamente, ter os valores 0 e 10000.
    Exemplo:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

func (*TagDiv) EnterKeyHint 

func (e *TagDiv) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagDiv)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagDiv) Get 

func (e *TagDiv) Get() (el js.Value)

func (*TagDiv) GetBottom 

func (e *TagDiv) GetBottom() (bottom int)

GetBottom

English: 

It is the same as y + height.

Português: 

É o mesmo que y + Height.

func (*TagDiv) GetLeft 

func (e *TagDiv) GetLeft() (left int)

GetLeft

English: 

Same as GetY() function, returns the y position of the element.

Português: 

O mesmo que a função GetY(), retorna a posição y do elemento.

func (*TagDiv) GetRight 

func (e *TagDiv) GetRight() (right int)

GetRight

English: 

It is the same as x + width.

Português: 

É o mesmo que x + width.

func (*TagDiv) GetRotateDelta 

func (e *TagDiv) GetRotateDelta() (delta float64)

GetRotateDelta

English: 

Returns the rotation adjustment angle, i.e. Rotate() = angle + delta.

 Output:
   angle: delta, object rotation adjustment angle.

Português: 

Retorna o ângulo de ajuste da rotação, ou seja, Rotate() = angle + delta.

 Saída:
   angle: delta, ângulo de ajuste da rotação do objeto.

func (*TagDiv) GetTop 

func (e *TagDiv) GetTop() (top int)

GetTop

English: 

Same as GetX() function, returns the x position of the element.

Português: 

O mesmo que a função GetX(), retorna a posição x do elemento.

func (*TagDiv) GetX 

func (e *TagDiv) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagDiv) GetXY 

func (e *TagDiv) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagDiv) GetY 

func (e *TagDiv) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagDiv) Hidden 

func (e *TagDiv) Hidden() (ref *TagDiv)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagDiv) Id 

func (e *TagDiv) Id(id string) (ref *TagDiv)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagDiv) Init 

func (e *TagDiv) Init() (ref *TagDiv)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagDiv) InputMode 

func (e *TagDiv) InputMode(inputMode InputMode) (ref *TagDiv)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagDiv) Is 

func (e *TagDiv) Is(is string) (ref *TagDiv)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagDiv) ItemDrop 

func (e *TagDiv) ItemDrop(itemprop string) (ref *TagDiv)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagDiv) ItemId 

func (e *TagDiv) ItemId(id string) (ref *TagDiv)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagDiv) ItemRef 

func (e *TagDiv) ItemRef(itemref string) (ref *TagDiv)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagDiv) ItemType 

func (e *TagDiv) ItemType(itemType string) (ref *TagDiv)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagDiv) Lang 

func (e *TagDiv) Lang(language Language) (ref *TagDiv)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagDiv) Mouse 

func (e *TagDiv) Mouse(value mouse.CursorType) (ref *TagDiv)

Mouse

English: 

Defines the shape of the mouse pointer.

 Input:
   value: mouse pointer shape.
     Example: SetMouse(mouse.KCursorCell) // Use mouse.K... and let autocomplete do the
              rest

Português: 

Define o formato do ponteiro do mouse.

 Entrada:
   value: formato do ponteiro do mouse.
     Exemplo: SetMouse(mouse.KCursorCell) // Use mouse.K... e deixe o autocompletar fazer
              o resto

func (*TagDiv) Nonce 

func (e *TagDiv) Nonce(part ...string) (ref *TagDiv)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagDiv) RemoveListener 

func (e *TagDiv) RemoveListener(eventType interface{}) (ref *TagDiv)

RemoveListener

English: 

Remove the function associated with the event

 Example:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

Português: 

Remove a função associada com o evento.

 Exemplo:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

func (*TagDiv) Rotate 

func (e *TagDiv) Rotate(angle float64) (ref *TagDiv)

Rotate

English: 

Defines a transformation that rotates an element around a fixed point on the 2D plane, without deforming it.

 Input:
   angle: representing the angle of the rotation. The direction of rotation depends on the writing direction.
   In a left-to-right context, a positive angle denotes a clockwise rotation, a negative angle a counter-clockwise
   one.
   In a right-to-left context, a positive angle denotes a counter-clockwise rotation, a negative angle a clockwise
   one.

Português: 

Define uma transformação que gira um elemento em torno de um ponto fixo no plano 2D, sem deformá-lo.

 Entrada:
   angle: representando o ângulo de rotação. O sentido de rotação depende do sentido de escrita.
   Em um contexto da esquerda para a direita, um ângulo positivo denota uma rotação no sentido horário, um ângulo
   negativo no sentido anti-horário.
   Em um contexto da direita para a esquerda, um ângulo positivo denota uma rotação no sentido anti-horário, um
   ângulo negativo denota uma rotação no sentido horário.

func (*TagDiv) RotateDelta 

func (e *TagDiv) RotateDelta(delta float64) (ref *TagDiv)

RotateDelta

English: 

Used in conjunction with the Rotate() function, sets the rotation adjustment angle, ie Rotate() = angle + delta.

 Input:
   angle: delta, object rotation adjustment angle.

Português: 

Usada em conjunto com a função Rotate(), define o ângulo de ajuste da rotação, ou seja, Rotate() = angle + delta.

 Entrada:
   angle: delta, ângulo de ajuste da rotação do objeto.

func (*TagDiv) SetDeltaX 

func (e *TagDiv) SetDeltaX(delta int) (ref *TagDiv)

SetDeltaX

English: 

Additional value added in the SetX() function: (x = x + deltaMovieX) and subtracted in the
GetX() function: (x = x - deltaMovieX).

Português: 

Valor adicional adicionado na função SetX(): (x = x + deltaMovieX)  e subtraído na função
GetX(): (x = x - deltaMovieX).

func (*TagDiv) SetDeltaY 

func (e *TagDiv) SetDeltaY(delta int) (ref *TagDiv)

SetDeltaY

English: 

Additional value added in the SetY() function: (y = y + deltaMovieY) and subtracted in the
GetY() function: (y = y - deltaMovieY).

Português: 

Valor adicional adicionado na função SetY(): (y = y + deltaMovieY)  e subtraído na função
GetX(): (y = y - deltaMovieY).

func (*TagDiv) SetX 

func (e *TagDiv) SetX(x int) (ref *TagDiv)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagDiv) SetXY 

func (e *TagDiv) SetXY(x, y int) (ref *TagDiv)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagDiv) SetY 

func (e *TagDiv) SetY(y int) (ref *TagDiv)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagDiv) Slot 

func (e *TagDiv) Slot(slot string) (ref *TagDiv)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagDiv) Spellcheck 

func (e *TagDiv) Spellcheck(spell bool) (ref *TagDiv)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagDiv) Style 

func (e *TagDiv) Style(style string) (ref *TagDiv)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagDiv) TabIndex 

func (e *TagDiv) TabIndex(index int) (ref *TagDiv)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagDiv) Title 

func (e *TagDiv) Title(title string) (ref *TagDiv)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagDiv) Translate 

func (e *TagDiv) Translate(translate Translate) (ref *TagDiv)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

type TagFieldset 

type TagFieldset struct {
	// contains filtered or unexported fields
}

func (*TagFieldset) AccessKey 

func (e *TagFieldset) AccessKey(key string) (ref *TagFieldset)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagFieldset) Append 

func (e *TagFieldset) Append(append interface{}) (ref *TagFieldset)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagFieldset) AppendById 

func (e *TagFieldset) AppendById(appendId string) (ref *TagFieldset)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagFieldset) Autofocus 

func (e *TagFieldset) Autofocus(autofocus bool) (ref *TagFieldset)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagFieldset) Class 

func (e *TagFieldset) Class(class ...string) (ref *TagFieldset)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

func (*TagFieldset) ContentEditable 

func (e *TagFieldset) ContentEditable(editable bool) (ref *TagFieldset)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagFieldset) CreateElement 

func (e *TagFieldset) CreateElement(tag Tag) (ref *TagFieldset)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagFieldset) Data 

func (e *TagFieldset) Data(data map[string]string) (ref *TagFieldset)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagFieldset) Dir 

func (e *TagFieldset) Dir(dir Dir) (ref *TagFieldset)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagFieldset) Disabled 

func (e *TagFieldset) Disabled(disabled bool) (ref *TagFieldset)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagFieldset) Draggable 

func (e *TagFieldset) Draggable(draggable Draggable) (ref *TagFieldset)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagFieldset) EnterKeyHint 

func (e *TagFieldset) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagFieldset)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagFieldset) Form 

func (e *TagFieldset) Form(form string) (ref *TagFieldset)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagFieldset) GetX 

func (e *TagFieldset) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagFieldset) GetXY 

func (e *TagFieldset) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagFieldset) GetY 

func (e *TagFieldset) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagFieldset) Hidden 

func (e *TagFieldset) Hidden() (ref *TagFieldset)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagFieldset) Id 

func (e *TagFieldset) Id(id string) (ref *TagFieldset)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagFieldset) InputMode 

func (e *TagFieldset) InputMode(inputMode InputMode) (ref *TagFieldset)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagFieldset) Is 

func (e *TagFieldset) Is(is string) (ref *TagFieldset)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagFieldset) ItemDrop 

func (e *TagFieldset) ItemDrop(itemprop string) (ref *TagFieldset)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagFieldset) ItemId 

func (e *TagFieldset) ItemId(id string) (ref *TagFieldset)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagFieldset) ItemRef 

func (e *TagFieldset) ItemRef(itemref string) (ref *TagFieldset)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagFieldset) ItemType 

func (e *TagFieldset) ItemType(itemType string) (ref *TagFieldset)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagFieldset) Lang 

func (e *TagFieldset) Lang(language Language) (ref *TagFieldset)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagFieldset) Name 

func (e *TagFieldset) Name(name string) (ref *TagFieldset)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagFieldset) Nonce 

func (e *TagFieldset) Nonce(part ...string) (ref *TagFieldset)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagFieldset) SetX 

func (e *TagFieldset) SetX(x int) (ref *TagFieldset)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagFieldset) SetXY 

func (e *TagFieldset) SetXY(x, y int) (ref *TagFieldset)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagFieldset) SetY 

func (e *TagFieldset) SetY(y int) (ref *TagFieldset)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagFieldset) Slot 

func (e *TagFieldset) Slot(slot string) (ref *TagFieldset)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagFieldset) Spellcheck 

func (e *TagFieldset) Spellcheck(spell bool) (ref *TagFieldset)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagFieldset) Style 

func (e *TagFieldset) Style(style string) (ref *TagFieldset)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagFieldset) TabIndex 

func (e *TagFieldset) TabIndex(index int) (ref *TagFieldset)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagFieldset) Title 

func (e *TagFieldset) Title(title string) (ref *TagFieldset)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagFieldset) Translate 

func (e *TagFieldset) Translate(translate Translate) (ref *TagFieldset)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

type TagFigCaption 

type TagFigCaption struct {
	// contains filtered or unexported fields
}

TagFigCaption

English:

The <figcaption> HTML element represents a caption or legend describing the rest of the contents of its parent <figure> element.

Português:

O elemento HTML <figcaption> representa uma legenda ou legenda descrevendo o restante do conteúdo de seu elemento pai <figure>.

func (*TagFigCaption) AccessKey 

func (e *TagFigCaption) AccessKey(key string) (ref *TagFigCaption)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagFigCaption) AddListener 

func (e *TagFigCaption) AddListener(eventType interface{}, manager mouse.SimpleManager) (ref *TagFigCaption)

AddListener

English: 

Associates a function with an event.

 Example:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

Português: 

Associa uma função a um evento.

 Exemplo:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

func (*TagFigCaption) AddPointsToEasingTween 

func (e *TagFigCaption) AddPointsToEasingTween(algorithmRef algorithm.CurveInterface) (ref *TagFigCaption)

AddPointsToEasingTween

English: 

This function returns an easing tween function compatible with the easing onStepFunc() function in order to use the
points generated by the line algorithms as a reference to the movement.

 Note:
   * The 'onStartValue' and 'onEndValue' parameters must have the values 0 and 10000.
     Example:
       factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

Português: 

Esta função retorna uma função easing tween compatível com a função onStepFunc() do easing de modo a usar os pontos
gerados pelos algoritmos de linha como referência ao movimento.

 Nota:
   * O parâmetros 'onStartValue' e 'onEndValue' devem, obrigatoriamente, ter os valores 0 e 10000.
     Exemplo:
       factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

func (*TagFigCaption) Append 

func (e *TagFigCaption) Append(elements ...Compatible) (ref *TagFigCaption)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

fixme: fazer append() assim em todas as tags html, exceto svg

func (*TagFigCaption) AppendById 

func (e *TagFigCaption) AppendById(appendId string) (ref *TagFigCaption)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagFigCaption) AppendToStage 

func (e *TagFigCaption) AppendToStage() (ref *TagFigCaption)

AppendToStage

English: 

Adds a node to the end of the list of children in the main document body. If the node already
exists somewhere in the document, it is removed from its current parent node before being added
to the main document.

Português: 

Adiciona um nó ao final da lista de filhos do corpo do documento principal. Se o nó já existir
em alguma parte do documento, ele é removido de seu nó pai atual antes de ser adicionado ao
documento principal.

todo:https://developer.mozilla.org/en-US/docs/Web/API/Document/createDocumentFragment todo: appendMany()

func (*TagFigCaption) Autofocus 

func (e *TagFigCaption) Autofocus(autofocus bool) (ref *TagFigCaption)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagFigCaption) Class 

func (e *TagFigCaption) Class(class ...string) (ref *TagFigCaption)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagFigCaption) ContentEditable 

func (e *TagFigCaption) ContentEditable(editable bool) (ref *TagFigCaption)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagFigCaption) CreateElement 

func (e *TagFigCaption) CreateElement() (ref *TagFigCaption)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagFigCaption) Data 

func (e *TagFigCaption) Data(data map[string]string) (ref *TagFigCaption)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagFigCaption) Dir 

func (e *TagFigCaption) Dir(dir Dir) (ref *TagFigCaption)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagFigCaption) DragStart 

func (e *TagFigCaption) DragStart() (ref *TagFigCaption)

DragStart

English: 

Mouse drag function.

 Example:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

Português: 

Função de arrastar com o mouse.

 Exemplo:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

func (*TagFigCaption) DragStop 

func (e *TagFigCaption) DragStop() (ref *TagFigCaption)

DragStop

English: 

Stop mouse drag functionality.

 Example:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

   go func() {
     time.Sleep(10 * time.Second)
     div.DragStop()
   }()

Português: 

Para a funcionalidade de arrastar com o mouse.

 Exemplo:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

   go func() {
     time.Sleep(10 * time.Second)
     div.DragStop()
   }()

func (*TagFigCaption) Draggable 

func (e *TagFigCaption) Draggable(draggable Draggable) (ref *TagFigCaption)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagFigCaption) EasingTweenWalkingAndRotateIntoPoints 

func (e *TagFigCaption) EasingTweenWalkingAndRotateIntoPoints() (function func(forTenThousand, percent float64, args interface{}))

EasingTweenWalkingAndRotateIntoPoints

English: 

Moves the element on the line added by the AddPointsToEasingTween() function and adjusts the rotation of the
element with respect to the next point.

This function returns a second function compatible with the easing tween's onStepFunc() function. 

Note:
  * Use the RotateDelta() function to adjust the starting angle;
  * The 'onStartValue' and 'onEndValue' parameters must have the values 0 and 10000.
    Example:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

Português: 

Desloca o elemento na linha adicionada pela função AddPointsToEasingTween() e ajusta a rotação do elemento em relação ao próximo ponto.

Esta função retorna uma segunda função compatível com a função onStepFunc() do easing tween. 

Nota:
  * Use a função RotateDelta() para ajustar o ângulo inicial;
  * O parâmetros 'onStartValue' e 'onEndValue' devem, obrigatoriamente, ter os valores 0 e 10000.
    Exemplo:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

func (*TagFigCaption) EasingTweenWalkingIntoPoints 

func (e *TagFigCaption) EasingTweenWalkingIntoPoints() (function func(percent, p float64, args interface{}))

EasingTweenWalkingIntoPoints

English: 

Moves the element on the line added by the AddPointsToEasingTween() function.

This function returns a second function compatible with the easing tween's onStepFunc() function. 

Note:
  * The 'onStartValue' and 'onEndValue' parameters must have the values 0 and 10000.
    Example:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

Português: 

Desloca o elemento na linha adicionada pela função AddPointsToEasingTween().

Esta função retorna uma segunda função compatível com a função onStepFunc() do easing tween. 

Nota:
  * O parâmetros 'onStartValue' e 'onEndValue' devem, obrigatoriamente, ter os valores 0 e 10000.
    Exemplo:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

func (*TagFigCaption) EnterKeyHint 

func (e *TagFigCaption) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagFigCaption)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagFigCaption) Get 

func (e *TagFigCaption) Get() (el js.Value)

func (*TagFigCaption) GetBottom 

func (e *TagFigCaption) GetBottom() (bottom int)

GetBottom

English: 

It is the same as y + height.

Português: 

É o mesmo que y + Height.

func (*TagFigCaption) GetLeft 

func (e *TagFigCaption) GetLeft() (left int)

GetLeft

English: 

Same as GetY() function, returns the y position of the element.

Português: 

O mesmo que a função GetY(), retorna a posição y do elemento.

func (*TagFigCaption) GetRight 

func (e *TagFigCaption) GetRight() (right int)

GetRight

English: 

It is the same as x + width.

Português: 

É o mesmo que x + width.

func (*TagFigCaption) GetRotateDelta 

func (e *TagFigCaption) GetRotateDelta() (delta float64)

GetRotateDelta

English: 

Returns the rotation adjustment angle, i.e. Rotate() = angle + delta.

 Output:
   angle: delta, object rotation adjustment angle.

Português: 

Retorna o ângulo de ajuste da rotação, ou seja, Rotate() = angle + delta.

 Saída:
   angle: delta, ângulo de ajuste da rotação do objeto.

func (*TagFigCaption) GetTop 

func (e *TagFigCaption) GetTop() (top int)

GetTop

English: 

Same as GetX() function, returns the x position of the element.

Português: 

O mesmo que a função GetX(), retorna a posição x do elemento.

func (*TagFigCaption) GetX 

func (e *TagFigCaption) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagFigCaption) GetXY 

func (e *TagFigCaption) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagFigCaption) GetY 

func (e *TagFigCaption) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagFigCaption) Hidden 

func (e *TagFigCaption) Hidden() (ref *TagFigCaption)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagFigCaption) Html 

func (e *TagFigCaption) Html(value string) (ref *TagFigCaption)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagFigCaption) Id 

func (e *TagFigCaption) Id(id string) (ref *TagFigCaption)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagFigCaption) Init 

func (e *TagFigCaption) Init() (ref *TagFigCaption)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagFigCaption) InputMode 

func (e *TagFigCaption) InputMode(inputMode InputMode) (ref *TagFigCaption)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagFigCaption) Is 

func (e *TagFigCaption) Is(is string) (ref *TagFigCaption)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagFigCaption) ItemDrop 

func (e *TagFigCaption) ItemDrop(itemprop string) (ref *TagFigCaption)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagFigCaption) ItemId 

func (e *TagFigCaption) ItemId(id string) (ref *TagFigCaption)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagFigCaption) ItemRef 

func (e *TagFigCaption) ItemRef(itemref string) (ref *TagFigCaption)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagFigCaption) ItemType 

func (e *TagFigCaption) ItemType(itemType string) (ref *TagFigCaption)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagFigCaption) Lang 

func (e *TagFigCaption) Lang(language Language) (ref *TagFigCaption)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagFigCaption) Mouse 

func (e *TagFigCaption) Mouse(value mouse.CursorType) (ref *TagFigCaption)

Mouse

English: 

Defines the shape of the mouse pointer.

 Input:
   value: mouse pointer shape.
     Example: SetMouse(mouse.KCursorCell) // Use mouse.K... and let autocomplete do the
              rest

Português: 

Define o formato do ponteiro do mouse.

 Entrada:
   value: formato do ponteiro do mouse.
     Exemplo: SetMouse(mouse.KCursorCell) // Use mouse.K... e deixe o autocompletar fazer
              o resto

func (*TagFigCaption) Nonce 

func (e *TagFigCaption) Nonce(part ...string) (ref *TagFigCaption)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagFigCaption) RemoveListener 

func (e *TagFigCaption) RemoveListener(eventType interface{}) (ref *TagFigCaption)

RemoveListener

English: 

Remove the function associated with the event

 Example:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

Português: 

Remove a função associada com o evento.

 Exemplo:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

func (*TagFigCaption) Rotate 

func (e *TagFigCaption) Rotate(angle float64) (ref *TagFigCaption)

Rotate

English: 

Defines a transformation that rotates an element around a fixed point on the 2D plane, without deforming it.

 Input:
   angle: representing the angle of the rotation. The direction of rotation depends on the writing direction.
   In a left-to-right context, a positive angle denotes a clockwise rotation, a negative angle a counter-clockwise
   one.
   In a right-to-left context, a positive angle denotes a counter-clockwise rotation, a negative angle a clockwise
   one.

Português: 

Define uma transformação que gira um elemento em torno de um ponto fixo no plano 2D, sem deformá-lo.

 Entrada:
   angle: representando o ângulo de rotação. O sentido de rotação depende do sentido de escrita.
   Em um contexto da esquerda para a direita, um ângulo positivo denota uma rotação no sentido horário, um ângulo
   negativo no sentido anti-horário.
   Em um contexto da direita para a esquerda, um ângulo positivo denota uma rotação no sentido anti-horário, um
   ângulo negativo denota uma rotação no sentido horário.

func (*TagFigCaption) RotateDelta 

func (e *TagFigCaption) RotateDelta(delta float64) (ref *TagFigCaption)

RotateDelta

English: 

Used in conjunction with the Rotate() function, sets the rotation adjustment angle, ie Rotate() = angle + delta.

 Input:
   angle: delta, object rotation adjustment angle.

Português: 

Usada em conjunto com a função Rotate(), define o ângulo de ajuste da rotação, ou seja, Rotate() = angle + delta.

 Entrada:
   angle: delta, ângulo de ajuste da rotação do objeto.

func (*TagFigCaption) SetDeltaX 

func (e *TagFigCaption) SetDeltaX(delta int) (ref *TagFigCaption)

SetDeltaX

English: 

Additional value added in the SetX() function: (x = x + deltaMovieX) and subtracted in the
GetX() function: (x = x - deltaMovieX).

Português: 

Valor adicional adicionado na função SetX(): (x = x + deltaMovieX)  e subtraído na função
GetX(): (x = x - deltaMovieX).

func (*TagFigCaption) SetDeltaY 

func (e *TagFigCaption) SetDeltaY(delta int) (ref *TagFigCaption)

SetDeltaY

English: 

Additional value added in the SetY() function: (y = y + deltaMovieY) and subtracted in the
GetY() function: (y = y - deltaMovieY).

Português: 

Valor adicional adicionado na função SetY(): (y = y + deltaMovieY)  e subtraído na função
GetX(): (y = y - deltaMovieY).

func (*TagFigCaption) SetX 

func (e *TagFigCaption) SetX(x int) (ref *TagFigCaption)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagFigCaption) SetXY 

func (e *TagFigCaption) SetXY(x, y int) (ref *TagFigCaption)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagFigCaption) SetY 

func (e *TagFigCaption) SetY(y int) (ref *TagFigCaption)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagFigCaption) Slot 

func (e *TagFigCaption) Slot(slot string) (ref *TagFigCaption)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagFigCaption) Spellcheck 

func (e *TagFigCaption) Spellcheck(spell bool) (ref *TagFigCaption)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagFigCaption) Style 

func (e *TagFigCaption) Style(style string) (ref *TagFigCaption)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagFigCaption) TabIndex 

func (e *TagFigCaption) TabIndex(index int) (ref *TagFigCaption)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagFigCaption) Text 

func (e *TagFigCaption) Text(value string) (ref *TagFigCaption)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagFigCaption) Title 

func (e *TagFigCaption) Title(title string) (ref *TagFigCaption)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagFigCaption) Translate 

func (e *TagFigCaption) Translate(translate Translate) (ref *TagFigCaption)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

type TagFigure 

type TagFigure struct {
	// contains filtered or unexported fields
}

TagFigure

English:

The <figure> HTML element represents self-contained content, potentially with an optional caption, which is specified using the <figcaption> element. The figure, its caption, and its contents are referenced as a single unit. 

Notes:
  * Usually a <figure> is an image, illustration, diagram, code snippet, etc., that is referenced
    in the main flow of a document, but that can be moved to another part of the document or to
    an appendix without affecting the main flow.
  * Being a sectioning root, the outline of the content of the <figure> element is excluded from
    the main outline of the document.
  * A caption can be associated with the <figure> element by inserting a <figcaption> inside it
    (as the first or the last child). The first <figcaption> element found in the figure is
    presented as the figure's caption.

Português:

O elemento HTML <figure> representa conteúdo autocontido, potencialmente com uma legenda opcional, que é especificada usando o elemento <figcaption>. A figura, sua legenda e seu conteúdo são referenciados como uma única unidade. 

Notas:
  * Normalmente uma <figura> é uma imagem, ilustração, diagrama, trecho de código, etc., que é
    referenciado no fluxo principal de um documento, mas que pode ser movido para outra parte do
    documento ou para um apêndice sem afetar o fluxo principal.
  * Sendo a seção principal, o contorno do conteúdo do elemento <figure> é excluído do contorno
    principal do documento.
  * Uma legenda pode ser associada ao elemento <figure> inserindo um <figcaption> dentro dele
    (como o primeiro ou o último filho). O primeiro elemento <figcaption> encontrado na figura é
    apresentado como legenda da figura.

func (*TagFigure) AccessKey 

func (e *TagFigure) AccessKey(key string) (ref *TagFigure)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagFigure) AddListener 

func (e *TagFigure) AddListener(eventType interface{}, manager mouse.SimpleManager) (ref *TagFigure)

AddListener

English: 

Associates a function with an event.

 Example:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

Português: 

Associa uma função a um evento.

 Exemplo:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

func (*TagFigure) AddPointsToEasingTween 

func (e *TagFigure) AddPointsToEasingTween(algorithmRef algorithm.CurveInterface) (ref *TagFigure)

AddPointsToEasingTween

English: 

This function returns an easing tween function compatible with the easing onStepFunc() function in order to use the
points generated by the line algorithms as a reference to the movement.

 Note:
   * The 'onStartValue' and 'onEndValue' parameters must have the values 0 and 10000.
     Example:
       factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

Português: 

Esta função retorna uma função easing tween compatível com a função onStepFunc() do easing de modo a usar os pontos
gerados pelos algoritmos de linha como referência ao movimento.

 Nota:
   * O parâmetros 'onStartValue' e 'onEndValue' devem, obrigatoriamente, ter os valores 0 e 10000.
     Exemplo:
       factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

func (*TagFigure) Append 

func (e *TagFigure) Append(elements ...Compatible) (ref *TagFigure)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

fixme: fazer append() assim em todas as tags html, exceto svg

func (*TagFigure) AppendById 

func (e *TagFigure) AppendById(appendId string) (ref *TagFigure)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagFigure) AppendToStage 

func (e *TagFigure) AppendToStage() (ref *TagFigure)

AppendToStage

English: 

Adds a node to the end of the list of children in the main document body. If the node already
exists somewhere in the document, it is removed from its current parent node before being added
to the main document.

Português: 

Adiciona um nó ao final da lista de filhos do corpo do documento principal. Se o nó já existir
em alguma parte do documento, ele é removido de seu nó pai atual antes de ser adicionado ao
documento principal.

todo:https://developer.mozilla.org/en-US/docs/Web/API/Document/createDocumentFragment todo: appendMany()

func (*TagFigure) Autofocus 

func (e *TagFigure) Autofocus(autofocus bool) (ref *TagFigure)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagFigure) Class 

func (e *TagFigure) Class(class ...string) (ref *TagFigure)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagFigure) ContentEditable 

func (e *TagFigure) ContentEditable(editable bool) (ref *TagFigure)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagFigure) CreateElement 

func (e *TagFigure) CreateElement() (ref *TagFigure)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagFigure) Data 

func (e *TagFigure) Data(data map[string]string) (ref *TagFigure)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagFigure) Dir 

func (e *TagFigure) Dir(dir Dir) (ref *TagFigure)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagFigure) DragStart 

func (e *TagFigure) DragStart() (ref *TagFigure)

DragStart

English: 

Mouse drag function.

 Example:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

Português: 

Função de arrastar com o mouse.

 Exemplo:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

func (*TagFigure) DragStop 

func (e *TagFigure) DragStop() (ref *TagFigure)

DragStop

English: 

Stop mouse drag functionality.

 Example:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

   go func() {
     time.Sleep(10 * time.Second)
     div.DragStop()
   }()

Português: 

Para a funcionalidade de arrastar com o mouse.

 Exemplo:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

   go func() {
     time.Sleep(10 * time.Second)
     div.DragStop()
   }()

func (*TagFigure) Draggable 

func (e *TagFigure) Draggable(draggable Draggable) (ref *TagFigure)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagFigure) EasingTweenWalkingAndRotateIntoPoints 

func (e *TagFigure) EasingTweenWalkingAndRotateIntoPoints() (function func(forTenThousand, percent float64, args interface{}))

EasingTweenWalkingAndRotateIntoPoints

English: 

Moves the element on the line added by the AddPointsToEasingTween() function and adjusts the rotation of the
element with respect to the next point.

This function returns a second function compatible with the easing tween's onStepFunc() function. 

Note:
  * Use the RotateDelta() function to adjust the starting angle;
  * The 'onStartValue' and 'onEndValue' parameters must have the values 0 and 10000.
    Example:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

Português: 

Desloca o elemento na linha adicionada pela função AddPointsToEasingTween() e ajusta a rotação do elemento em relação ao próximo ponto.

Esta função retorna uma segunda função compatível com a função onStepFunc() do easing tween. 

Nota:
  * Use a função RotateDelta() para ajustar o ângulo inicial;
  * O parâmetros 'onStartValue' e 'onEndValue' devem, obrigatoriamente, ter os valores 0 e 10000.
    Exemplo:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

func (*TagFigure) EasingTweenWalkingIntoPoints 

func (e *TagFigure) EasingTweenWalkingIntoPoints() (function func(percent, p float64, args interface{}))

EasingTweenWalkingIntoPoints

English: 

Moves the element on the line added by the AddPointsToEasingTween() function.

This function returns a second function compatible with the easing tween's onStepFunc() function. 

Note:
  * The 'onStartValue' and 'onEndValue' parameters must have the values 0 and 10000.
    Example:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

Português: 

Desloca o elemento na linha adicionada pela função AddPointsToEasingTween().

Esta função retorna uma segunda função compatível com a função onStepFunc() do easing tween. 

Nota:
  * O parâmetros 'onStartValue' e 'onEndValue' devem, obrigatoriamente, ter os valores 0 e 10000.
    Exemplo:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

func (*TagFigure) EnterKeyHint 

func (e *TagFigure) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagFigure)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagFigure) Get 

func (e *TagFigure) Get() (el js.Value)

func (*TagFigure) GetBottom 

func (e *TagFigure) GetBottom() (bottom int)

GetBottom

English: 

It is the same as y + height.

Português: 

É o mesmo que y + Height.

func (*TagFigure) GetLeft 

func (e *TagFigure) GetLeft() (left int)

GetLeft

English: 

Same as GetY() function, returns the y position of the element.

Português: 

O mesmo que a função GetY(), retorna a posição y do elemento.

func (*TagFigure) GetRight 

func (e *TagFigure) GetRight() (right int)

GetRight

English: 

It is the same as x + width.

Português: 

É o mesmo que x + width.

func (*TagFigure) GetRotateDelta 

func (e *TagFigure) GetRotateDelta() (delta float64)

GetRotateDelta

English: 

Returns the rotation adjustment angle, i.e. Rotate() = angle + delta.

 Output:
   angle: delta, object rotation adjustment angle.

Português: 

Retorna o ângulo de ajuste da rotação, ou seja, Rotate() = angle + delta.

 Saída:
   angle: delta, ângulo de ajuste da rotação do objeto.

func (*TagFigure) GetTop 

func (e *TagFigure) GetTop() (top int)

GetTop

English: 

Same as GetX() function, returns the x position of the element.

Português: 

O mesmo que a função GetX(), retorna a posição x do elemento.

func (*TagFigure) GetX 

func (e *TagFigure) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagFigure) GetXY 

func (e *TagFigure) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagFigure) GetY 

func (e *TagFigure) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagFigure) Hidden 

func (e *TagFigure) Hidden() (ref *TagFigure)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagFigure) Html 

func (e *TagFigure) Html(value string) (ref *TagFigure)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagFigure) Id 

func (e *TagFigure) Id(id string) (ref *TagFigure)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagFigure) Init 

func (e *TagFigure) Init() (ref *TagFigure)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagFigure) InputMode 

func (e *TagFigure) InputMode(inputMode InputMode) (ref *TagFigure)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagFigure) Is 

func (e *TagFigure) Is(is string) (ref *TagFigure)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagFigure) ItemDrop 

func (e *TagFigure) ItemDrop(itemprop string) (ref *TagFigure)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagFigure) ItemId 

func (e *TagFigure) ItemId(id string) (ref *TagFigure)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagFigure) ItemRef 

func (e *TagFigure) ItemRef(itemref string) (ref *TagFigure)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagFigure) ItemType 

func (e *TagFigure) ItemType(itemType string) (ref *TagFigure)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagFigure) Lang 

func (e *TagFigure) Lang(language Language) (ref *TagFigure)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagFigure) Mouse 

func (e *TagFigure) Mouse(value mouse.CursorType) (ref *TagFigure)

Mouse

English: 

Defines the shape of the mouse pointer.

 Input:
   value: mouse pointer shape.
     Example: SetMouse(mouse.KCursorCell) // Use mouse.K... and let autocomplete do the
              rest

Português: 

Define o formato do ponteiro do mouse.

 Entrada:
   value: formato do ponteiro do mouse.
     Exemplo: SetMouse(mouse.KCursorCell) // Use mouse.K... e deixe o autocompletar fazer
              o resto

func (*TagFigure) Nonce 

func (e *TagFigure) Nonce(part ...string) (ref *TagFigure)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagFigure) RemoveListener 

func (e *TagFigure) RemoveListener(eventType interface{}) (ref *TagFigure)

RemoveListener

English: 

Remove the function associated with the event

 Example:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

Português: 

Remove a função associada com o evento.

 Exemplo:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

func (*TagFigure) Rotate 

func (e *TagFigure) Rotate(angle float64) (ref *TagFigure)

Rotate

English: 

Defines a transformation that rotates an element around a fixed point on the 2D plane, without deforming it.

 Input:
   angle: representing the angle of the rotation. The direction of rotation depends on the writing direction.
   In a left-to-right context, a positive angle denotes a clockwise rotation, a negative angle a counter-clockwise
   one.
   In a right-to-left context, a positive angle denotes a counter-clockwise rotation, a negative angle a clockwise
   one.

Português: 

Define uma transformação que gira um elemento em torno de um ponto fixo no plano 2D, sem deformá-lo.

 Entrada:
   angle: representando o ângulo de rotação. O sentido de rotação depende do sentido de escrita.
   Em um contexto da esquerda para a direita, um ângulo positivo denota uma rotação no sentido horário, um ângulo
   negativo no sentido anti-horário.
   Em um contexto da direita para a esquerda, um ângulo positivo denota uma rotação no sentido anti-horário, um
   ângulo negativo denota uma rotação no sentido horário.

func (*TagFigure) RotateDelta 

func (e *TagFigure) RotateDelta(delta float64) (ref *TagFigure)

RotateDelta

English: 

Used in conjunction with the Rotate() function, sets the rotation adjustment angle, ie Rotate() = angle + delta.

 Input:
   angle: delta, object rotation adjustment angle.

Português: 

Usada em conjunto com a função Rotate(), define o ângulo de ajuste da rotação, ou seja, Rotate() = angle + delta.

 Entrada:
   angle: delta, ângulo de ajuste da rotação do objeto.

func (*TagFigure) SetDeltaX 

func (e *TagFigure) SetDeltaX(delta int) (ref *TagFigure)

SetDeltaX

English: 

Additional value added in the SetX() function: (x = x + deltaMovieX) and subtracted in the
GetX() function: (x = x - deltaMovieX).

Português: 

Valor adicional adicionado na função SetX(): (x = x + deltaMovieX)  e subtraído na função
GetX(): (x = x - deltaMovieX).

func (*TagFigure) SetDeltaY 

func (e *TagFigure) SetDeltaY(delta int) (ref *TagFigure)

SetDeltaY

English: 

Additional value added in the SetY() function: (y = y + deltaMovieY) and subtracted in the
GetY() function: (y = y - deltaMovieY).

Português: 

Valor adicional adicionado na função SetY(): (y = y + deltaMovieY)  e subtraído na função
GetX(): (y = y - deltaMovieY).

func (*TagFigure) SetX 

func (e *TagFigure) SetX(x int) (ref *TagFigure)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagFigure) SetXY 

func (e *TagFigure) SetXY(x, y int) (ref *TagFigure)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagFigure) SetY 

func (e *TagFigure) SetY(y int) (ref *TagFigure)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagFigure) Slot 

func (e *TagFigure) Slot(slot string) (ref *TagFigure)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagFigure) Spellcheck 

func (e *TagFigure) Spellcheck(spell bool) (ref *TagFigure)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagFigure) Style 

func (e *TagFigure) Style(style string) (ref *TagFigure)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagFigure) TabIndex 

func (e *TagFigure) TabIndex(index int) (ref *TagFigure)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagFigure) Text 

func (e *TagFigure) Text(value string) (ref *TagFigure)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagFigure) Title 

func (e *TagFigure) Title(title string) (ref *TagFigure)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagFigure) Translate 

func (e *TagFigure) Translate(translate Translate) (ref *TagFigure)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

type TagForm 

type TagForm struct {
	// contains filtered or unexported fields
}

func (*TagForm) AccessKey 

func (e *TagForm) AccessKey(key string) (ref *TagForm)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagForm) Action 

func (e *TagForm) Action(action string) (ref *TagForm)

Action

English: 

The URL that processes the form submission. This value can be overridden by a formaction
attribute on a <button>, <input type="submit">, or <input type="image"> element.

This attribute is ignored when method="dialog" is set.

Português: 

A URL que processa o envio do formulário. Esse valor pode ser substituído por um atributo
formaction em um elemento <button>, <input type="submit"> ou <input type="image">.

Este atributo é ignorado quando method="dialog" é definido.

func (*TagForm) Append 

func (e *TagForm) Append(append interface{}) (ref *TagForm)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagForm) AppendById 

func (e *TagForm) AppendById(appendId string) (ref *TagForm)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagForm) Autocomplete 

func (e *TagForm) Autocomplete(autocomplete Autocomplete) (ref *TagForm)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagForm) Autofocus 

func (e *TagForm) Autofocus(autofocus bool) (ref *TagForm)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagForm) Charset 

func (e *TagForm) Charset(value string) (ref *TagForm)

Charset

English: 

Space-separated character encodings the server accepts. The browser uses them in the order in
which they are listed. The default value means the same encoding as the page.
(In previous versions of HTML, character encodings could also be delimited by commas.)

Português: 

Codificações de caracteres separados por espaço que o servidor aceita. O navegador os utiliza na
ordem em que estão listados. O valor padrão significa a mesma codificação da página.
(Nas versões anteriores do HTML, as codificações de caracteres também podiam ser delimitadas
por vírgulas.)

func (*TagForm) Class 

func (e *TagForm) Class(class ...string) (ref *TagForm)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagForm) ContentEditable 

func (e *TagForm) ContentEditable(editable bool) (ref *TagForm)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagForm) CreateElement 

func (e *TagForm) CreateElement(tag Tag) (ref *TagForm)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagForm) Data 

func (e *TagForm) Data(data map[string]string) (ref *TagForm)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagForm) Dir 

func (e *TagForm) Dir(dir Dir) (ref *TagForm)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagForm) Draggable 

func (e *TagForm) Draggable(draggable Draggable) (ref *TagForm)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagForm) EncType 

func (e *TagForm) EncType(formenctype FormEncType) (ref *TagForm)

EncType

English: 

If the button is a submit button (it's inside/associated with a <form> and doesn't have
type="button"), specifies how to encode the form data that is submitted. Possible values:

 Input:
   formenctype: specifies how to encode the form data

     application/x-www-form-urlencoded: The default if the attribute is not used.
     multipart/form-data: Use to submit <input> elements with their type attributes set to file.
     text/plain: Specified as a debugging aid; shouldn't be used for real form submission.

 Note:
   * If this attribute is specified, it overrides the enctype attribute of the button's form
     owner.

Português: 

Se o botão for um botão de envio (está associado a um <form> e não possui type="button"),
especifica como codificar os dados do formulário que são enviados. Valores possíveis:

 Entrada:
   formenctype: especifica como codificar os dados do formulário

     KFormEncTypeApplication: O padrão se o atributo não for usado.
     KFormEncTypeMultiPart: Use para enviar elementos <input> com seus atributos de tipo definidos
       para arquivo.
     KFormEncTypeText: Especificado como auxiliar de depuração; não deve ser usado para envio de
       formulário real.

 Note:
   * Se este atributo for especificado, ele substituirá o atributo enctype do proprietário do
     formulário do botão.

func (*TagForm) EnterKeyHint 

func (e *TagForm) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagForm)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagForm) GetX 

func (e *TagForm) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagForm) GetXY 

func (e *TagForm) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagForm) GetY 

func (e *TagForm) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagForm) Hidden 

func (e *TagForm) Hidden() (ref *TagForm)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagForm) Id 

func (e *TagForm) Id(id string) (ref *TagForm)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagForm) InputMode 

func (e *TagForm) InputMode(inputMode InputMode) (ref *TagForm)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagForm) Is 

func (e *TagForm) Is(is string) (ref *TagForm)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagForm) ItemDrop 

func (e *TagForm) ItemDrop(itemprop string) (ref *TagForm)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagForm) ItemId 

func (e *TagForm) ItemId(id string) (ref *TagForm)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagForm) ItemRef 

func (e *TagForm) ItemRef(itemref string) (ref *TagForm)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagForm) ItemType 

func (e *TagForm) ItemType(itemType string) (ref *TagForm)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagForm) Lang 

func (e *TagForm) Lang(language Language) (ref *TagForm)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagForm) Method 

func (e *TagForm) Method(method FormMethod) (ref *TagForm)

Method

English: 

If the button is a submit button (it's inside/associated with a <form> and doesn't have
type="button"), this attribute specifies the HTTP method used to submit the form.

 Input:
   method: specifies the HTTP method used to submit
     KFormMethodPost: The data from the form are included in the body of the HTTP request when
       sent to the server. Use when the form contains information that shouldn't be public, like
       login credentials;
     KFormMethodGet: The form data are appended to the form's action URL, with a ? as a separator,
       and the resulting URL is sent to the server. Use this method when the form has no side
       effects, like search forms;
     KFormMethodDialog: When the form is inside a <dialog>, closes the dialog and throws a submit
       event on submission without submitting data or clearing the form.

 Note:
   * If specified, this attribute overrides the method attribute of the button's form owner.

Português: 

Se o botão for um botão de envio (está associado a um <form> e não possui type="button"),
este atributo especifica o método HTTP usado para enviar o formulário.

 Input:
   method: especifica o método HTTP usado para enviar
     KFormMethodPost: Os dados do formulário são incluídos no corpo da solicitação HTTP quando
       enviados ao servidor. Use quando o formulário contém informações que não devem ser
       públicas, como credenciais de login;
     KFormMethodGet: Os dados do formulário são anexados à URL de ação do formulário, com um ?
       como separador e a URL resultante é enviada ao servidor. Use este método quando o
       formulário não tiver efeitos colaterais, como formulários de pesquisa;
     KFormMethodDialog: Quando o formulário está dentro de um <dialog>, fecha o diálogo e lança um
       evento submit no envio sem enviar dados ou limpar o formulário.

 Nota:
   * Se especificado, este atributo substitui o atributo method do proprietário do formulário do
     botão.

func (*TagForm) Name 

func (e *TagForm) Name(name string) (ref *TagForm)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagForm) Nonce 

func (e *TagForm) Nonce(part ...string) (ref *TagForm)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagForm) Novalidate 

func (e *TagForm) Novalidate(novalidate string) (ref *TagForm)

Novalidate

English: 

This Boolean attribute indicates that the form shouldn't be validated when submitted.

If this attribute is not set (and therefore the form is validated), it can be overridden by a formnovalidate attribute on a <button>, <input type="submit">, or <input type="image"> element belonging to the form.

Português: 

Este atributo booleano indica que o formulário não deve ser validado quando enviado.

Se este atributo não estiver definido (e, portanto, o formulário for validado), ele poderá ser substituído por um atributo formnovalidate em um elemento <button>, <input type="submit"> ou <input type="image"> pertencente a a forma.

func (*TagForm) Rel 

func (e *TagForm) Rel(rel string) (ref *TagForm)

Rel

English: 

The relationship of the linked URL as space-separated link types.

Português: 

O relacionamento da URL vinculada como tipos de link separados por espaço.

func (*TagForm) SetX 

func (e *TagForm) SetX(x int) (ref *TagForm)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagForm) SetXY 

func (e *TagForm) SetXY(x, y int) (ref *TagForm)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagForm) SetY 

func (e *TagForm) SetY(y int) (ref *TagForm)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagForm) Slot 

func (e *TagForm) Slot(slot string) (ref *TagForm)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagForm) Spellcheck 

func (e *TagForm) Spellcheck(spell bool) (ref *TagForm)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagForm) Style 

func (e *TagForm) Style(style string) (ref *TagForm)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagForm) TabIndex 

func (e *TagForm) TabIndex(index int) (ref *TagForm)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagForm) Target 

func (e *TagForm) Target(target Target) (ref *TagForm)

Target

English:

Where to display the linked URL, as the name for a browsing context (a tab, window, or <iframe>). The following keywords have special meanings for where to load the URL: 

KTargetSelf: the current browsing context; (Default)
KTargetBlank: usually a new tab, but users can configure browsers to open a new window instead;
KTargetParent: the parent browsing context of the current one. If no parent, behaves as _self;
KTargetTop: the topmost browsing context (the "highest" context that's an ancestor of the current
  one). If no ancestors, behaves as _self.

Note:
  * Setting KTargetBlank on <a> elements implicitly provides the same rel behavior as setting
    rel="noopener" which does not set window.opener. See browser compatibility for support
    status.

Português:

Onde exibir a URL vinculada, como o nome de um contexto de navegação (uma guia, janela ou <iframe>). As seguintes palavras-chave têm significados especiais para onde carregar o URL: 

KTargetSelf: o contexto de navegação atual; (padrão)
KTargetBlank: geralmente uma nova guia, mas os usuários podem configurar os navegadores para
  abrir uma nova janela;
KTargetParent: o contexto de navegação pai do atual. Se nenhum pai, se comporta como _self;
KTargetTop: o contexto de navegação mais alto (o contexto "mais alto" que é um ancestral do
  atual). Se não houver ancestrais, se comporta como _self.

Nota:
  * Definir KTargetBlank em elementos <a> fornece implicitamente o mesmo comportamento rel
    que definir rel="noopener" que não define window.opener. Consulte a compatibilidade do
    navegador para obter o status do suporte.

func (*TagForm) Title 

func (e *TagForm) Title(title string) (ref *TagForm)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagForm) Translate 

func (e *TagForm) Translate(translate Translate) (ref *TagForm)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

type TagH1 

type TagH1 struct {
	// contains filtered or unexported fields
}

TagH1

English:

The <h1> to <h6> HTML elements represent six levels of section headings. <h1> is the highest section level and <h6> is the lowest.

Multiple <h1> elements on one page

Using more than one <h1> is allowed by the HTML specification, but is not considered a best practice. Using only one <h1> is beneficial for screenreader users.

The HTML specification includes the concept of an outline formed by the use of <section> elements. If this were implemented it would enable the use of multiple <h1> elements, giving user agents—including screen readers—a way to understand that an <h1> nested inside a defined section is a subheading. This functionality has never been implemented; therefore it is important to use your headings to describe the outline of your document. 

Notes:
  * Heading information can be used by user agents to construct a table of contents for a
    document automatically.
  * Avoid using heading elements to resize text. Instead, use the CSS font-size property.
  * Avoid skipping heading levels: always start from <h1>, followed by <h2> and so on.
  * Use only one <h1> per page or view. It should concisely describe the overall purpose of the
    content.
  * The align attribute is obsolete; don't use it.

Português:

Os elementos HTML <h1> a <h6> representam seis níveis de cabeçalho, onde, <h1> é o nível mais alto e <h6> o nível mais baixo.

Múltiplos elementos <h1> em uma página

O uso de mais de um <h1> é permitido pela especificação HTML, mas não é considerado uma prática recomendada. Usar apenas um <h1> é benéfico para usuários de leitores de tela.

A especificação HTML inclui o conceito de contorno formado pelo uso de elementos <section>. Se isso fosse implementado, permitiria o uso de vários elementos <h1>, dando aos agentes do usuário – incluindo leitores de tela – uma maneira de entender que um <h1> aninhado dentro de uma seção definida é um subtítulo. Essa funcionalidade nunca foi implementada; portanto, é importante usar seus títulos para descrever o esboço do seu documento. 

Notas:
  * As informações de cabeçalho podem ser usadas por agentes de usuário para construir
    automaticamente um índice para um documento.
  * Evite usar elementos de título para redimensionar o texto. Em vez disso, use a propriedade
    CSS font-size.
  * Evite pular níveis de título: sempre comece de <h1>, seguido de <h2> e assim por diante.
  * Use apenas um <h1> por página ou visualização. Deve descrever de forma concisa o propósito
    geral do conteúdo.
  * O atributo align está obsoleto; não o use.

func (*TagH1) AccessKey 

func (e *TagH1) AccessKey(key string) (ref *TagH1)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagH1) AddListener 

func (e *TagH1) AddListener(eventType interface{}, manager mouse.SimpleManager) (ref *TagH1)

AddListener

English: 

Associates a function with an event.

 Example:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

Português: 

Associa uma função a um evento.

 Exemplo:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

func (*TagH1) AddPointsToEasingTween 

func (e *TagH1) AddPointsToEasingTween(algorithmRef algorithm.CurveInterface) (ref *TagH1)

AddPointsToEasingTween

English: 

This function returns an easing tween function compatible with the easing onStepFunc() function in order to use the
points generated by the line algorithms as a reference to the movement.

 Note:
   * The 'onStartValue' and 'onEndValue' parameters must have the values 0 and 10000.
     Example:
       factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

Português: 

Esta função retorna uma função easing tween compatível com a função onStepFunc() do easing de modo a usar os pontos
gerados pelos algoritmos de linha como referência ao movimento.

 Nota:
   * O parâmetros 'onStartValue' e 'onEndValue' devem, obrigatoriamente, ter os valores 0 e 10000.
     Exemplo:
       factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

func (*TagH1) Append 

func (e *TagH1) Append(elements ...Compatible) (ref *TagH1)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

fixme: fazer append() assim em todas as tags html, exceto svg

func (*TagH1) AppendById 

func (e *TagH1) AppendById(appendId string) (ref *TagH1)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagH1) AppendToStage 

func (e *TagH1) AppendToStage() (ref *TagH1)

AppendToStage

English: 

Adds a node to the end of the list of children in the main document body. If the node already
exists somewhere in the document, it is removed from its current parent node before being added
to the main document.

Português: 

Adiciona um nó ao final da lista de filhos do corpo do documento principal. Se o nó já existir
em alguma parte do documento, ele é removido de seu nó pai atual antes de ser adicionado ao
documento principal.

todo:https://developer.mozilla.org/en-US/docs/Web/API/Document/createDocumentFragment todo: appendMany()

func (*TagH1) Autofocus 

func (e *TagH1) Autofocus(autofocus bool) (ref *TagH1)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagH1) Class 

func (e *TagH1) Class(class ...string) (ref *TagH1)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagH1) ContentEditable 

func (e *TagH1) ContentEditable(editable bool) (ref *TagH1)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagH1) CreateElement 

func (e *TagH1) CreateElement() (ref *TagH1)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagH1) Data 

func (e *TagH1) Data(data map[string]string) (ref *TagH1)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagH1) Dir 

func (e *TagH1) Dir(dir Dir) (ref *TagH1)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagH1) DragStart 

func (e *TagH1) DragStart() (ref *TagH1)

DragStart

English: 

Mouse drag function.

 Example:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

Português: 

Função de arrastar com o mouse.

 Exemplo:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

func (*TagH1) DragStop 

func (e *TagH1) DragStop() (ref *TagH1)

DragStop

English: 

Stop mouse drag functionality.

 Example:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

   go func() {
     time.Sleep(10 * time.Second)
     div.DragStop()
   }()

Português: 

Para a funcionalidade de arrastar com o mouse.

 Exemplo:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

   go func() {
     time.Sleep(10 * time.Second)
     div.DragStop()
   }()

func (*TagH1) Draggable 

func (e *TagH1) Draggable(draggable Draggable) (ref *TagH1)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagH1) EasingTweenWalkingAndRotateIntoPoints 

func (e *TagH1) EasingTweenWalkingAndRotateIntoPoints() (function func(forTenThousand, percent float64, args interface{}))

EasingTweenWalkingAndRotateIntoPoints

English: 

Moves the element on the line added by the AddPointsToEasingTween() function and adjusts the rotation of the
element with respect to the next point.

This function returns a second function compatible with the easing tween's onStepFunc() function. 

Note:
  * Use the RotateDelta() function to adjust the starting angle;
  * The 'onStartValue' and 'onEndValue' parameters must have the values 0 and 10000.
    Example:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

Português: 

Desloca o elemento na linha adicionada pela função AddPointsToEasingTween() e ajusta a rotação do elemento em relação ao próximo ponto.

Esta função retorna uma segunda função compatível com a função onStepFunc() do easing tween. 

Nota:
  * Use a função RotateDelta() para ajustar o ângulo inicial;
  * O parâmetros 'onStartValue' e 'onEndValue' devem, obrigatoriamente, ter os valores 0 e 10000.
    Exemplo:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

func (*TagH1) EasingTweenWalkingIntoPoints 

func (e *TagH1) EasingTweenWalkingIntoPoints() (function func(percent, p float64, args interface{}))

EasingTweenWalkingIntoPoints

English: 

Moves the element on the line added by the AddPointsToEasingTween() function.

This function returns a second function compatible with the easing tween's onStepFunc() function. 

Note:
  * The 'onStartValue' and 'onEndValue' parameters must have the values 0 and 10000.
    Example:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

Português: 

Desloca o elemento na linha adicionada pela função AddPointsToEasingTween().

Esta função retorna uma segunda função compatível com a função onStepFunc() do easing tween. 

Nota:
  * O parâmetros 'onStartValue' e 'onEndValue' devem, obrigatoriamente, ter os valores 0 e 10000.
    Exemplo:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

func (*TagH1) EnterKeyHint 

func (e *TagH1) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagH1)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagH1) Get 

func (e *TagH1) Get() (el js.Value)

func (*TagH1) GetBottom 

func (e *TagH1) GetBottom() (bottom int)

GetBottom

English: 

It is the same as y + height.

Português: 

É o mesmo que y + Height.

func (*TagH1) GetLeft 

func (e *TagH1) GetLeft() (left int)

GetLeft

English: 

Same as GetY() function, returns the y position of the element.

Português: 

O mesmo que a função GetY(), retorna a posição y do elemento.

func (*TagH1) GetRight 

func (e *TagH1) GetRight() (right int)

GetRight

English: 

It is the same as x + width.

Português: 

É o mesmo que x + width.

func (*TagH1) GetRotateDelta 

func (e *TagH1) GetRotateDelta() (delta float64)

GetRotateDelta

English: 

Returns the rotation adjustment angle, i.e. Rotate() = angle + delta.

 Output:
   angle: delta, object rotation adjustment angle.

Português: 

Retorna o ângulo de ajuste da rotação, ou seja, Rotate() = angle + delta.

 Saída:
   angle: delta, ângulo de ajuste da rotação do objeto.

func (*TagH1) GetTop 

func (e *TagH1) GetTop() (top int)

GetTop

English: 

Same as GetX() function, returns the x position of the element.

Português: 

O mesmo que a função GetX(), retorna a posição x do elemento.

func (*TagH1) GetX 

func (e *TagH1) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagH1) GetXY 

func (e *TagH1) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagH1) GetY 

func (e *TagH1) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagH1) Hidden 

func (e *TagH1) Hidden() (ref *TagH1)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagH1) Html 

func (e *TagH1) Html(value string) (ref *TagH1)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagH1) Id 

func (e *TagH1) Id(id string) (ref *TagH1)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagH1) Init 

func (e *TagH1) Init() (ref *TagH1)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagH1) InputMode 

func (e *TagH1) InputMode(inputMode InputMode) (ref *TagH1)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagH1) Is 

func (e *TagH1) Is(is string) (ref *TagH1)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagH1) ItemDrop 

func (e *TagH1) ItemDrop(itemprop string) (ref *TagH1)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagH1) ItemId 

func (e *TagH1) ItemId(id string) (ref *TagH1)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagH1) ItemRef 

func (e *TagH1) ItemRef(itemref string) (ref *TagH1)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagH1) ItemType 

func (e *TagH1) ItemType(itemType string) (ref *TagH1)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagH1) Lang 

func (e *TagH1) Lang(language Language) (ref *TagH1)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagH1) Mouse 

func (e *TagH1) Mouse(value mouse.CursorType) (ref *TagH1)

Mouse

English: 

Defines the shape of the mouse pointer.

 Input:
   value: mouse pointer shape.
     Example: SetMouse(mouse.KCursorCell) // Use mouse.K... and let autocomplete do the
              rest

Português: 

Define o formato do ponteiro do mouse.

 Entrada:
   value: formato do ponteiro do mouse.
     Exemplo: SetMouse(mouse.KCursorCell) // Use mouse.K... e deixe o autocompletar fazer
              o resto

func (*TagH1) Nonce 

func (e *TagH1) Nonce(part ...string) (ref *TagH1)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagH1) RemoveListener 

func (e *TagH1) RemoveListener(eventType interface{}) (ref *TagH1)

RemoveListener

English: 

Remove the function associated with the event

 Example:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

Português: 

Remove a função associada com o evento.

 Exemplo:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

func (*TagH1) Rotate 

func (e *TagH1) Rotate(angle float64) (ref *TagH1)

Rotate

English: 

Defines a transformation that rotates an element around a fixed point on the 2D plane, without deforming it.

 Input:
   angle: representing the angle of the rotation. The direction of rotation depends on the writing direction.
   In a left-to-right context, a positive angle denotes a clockwise rotation, a negative angle a counter-clockwise
   one.
   In a right-to-left context, a positive angle denotes a counter-clockwise rotation, a negative angle a clockwise
   one.

Português: 

Define uma transformação que gira um elemento em torno de um ponto fixo no plano 2D, sem deformá-lo.

 Entrada:
   angle: representando o ângulo de rotação. O sentido de rotação depende do sentido de escrita.
   Em um contexto da esquerda para a direita, um ângulo positivo denota uma rotação no sentido horário, um ângulo
   negativo no sentido anti-horário.
   Em um contexto da direita para a esquerda, um ângulo positivo denota uma rotação no sentido anti-horário, um
   ângulo negativo denota uma rotação no sentido horário.

func (*TagH1) RotateDelta 

func (e *TagH1) RotateDelta(delta float64) (ref *TagH1)

RotateDelta

English: 

Used in conjunction with the Rotate() function, sets the rotation adjustment angle, ie Rotate() = angle + delta.

 Input:
   angle: delta, object rotation adjustment angle.

Português: 

Usada em conjunto com a função Rotate(), define o ângulo de ajuste da rotação, ou seja, Rotate() = angle + delta.

 Entrada:
   angle: delta, ângulo de ajuste da rotação do objeto.

func (*TagH1) SetDeltaX 

func (e *TagH1) SetDeltaX(delta int) (ref *TagH1)

SetDeltaX

English: 

Additional value added in the SetX() function: (x = x + deltaMovieX) and subtracted in the
GetX() function: (x = x - deltaMovieX).

Português: 

Valor adicional adicionado na função SetX(): (x = x + deltaMovieX)  e subtraído na função
GetX(): (x = x - deltaMovieX).

func (*TagH1) SetDeltaY 

func (e *TagH1) SetDeltaY(delta int) (ref *TagH1)

SetDeltaY

English: 

Additional value added in the SetY() function: (y = y + deltaMovieY) and subtracted in the
GetY() function: (y = y - deltaMovieY).

Português: 

Valor adicional adicionado na função SetY(): (y = y + deltaMovieY)  e subtraído na função
GetX(): (y = y - deltaMovieY).

func (*TagH1) SetX 

func (e *TagH1) SetX(x int) (ref *TagH1)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagH1) SetXY 

func (e *TagH1) SetXY(x, y int) (ref *TagH1)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagH1) SetY 

func (e *TagH1) SetY(y int) (ref *TagH1)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagH1) Slot 

func (e *TagH1) Slot(slot string) (ref *TagH1)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagH1) Spellcheck 

func (e *TagH1) Spellcheck(spell bool) (ref *TagH1)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagH1) Style 

func (e *TagH1) Style(style string) (ref *TagH1)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagH1) TabIndex 

func (e *TagH1) TabIndex(index int) (ref *TagH1)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagH1) Text 

func (e *TagH1) Text(value string) (ref *TagH1)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagH1) Title 

func (e *TagH1) Title(title string) (ref *TagH1)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagH1) Translate 

func (e *TagH1) Translate(translate Translate) (ref *TagH1)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

type TagH2 

type TagH2 struct {
	// contains filtered or unexported fields
}

TagH2

English:

The <h1> to <h6> HTML elements represent six levels of section headings. <h1> is the highest section level and <h6> is the lowest.

Multiple <h1> elements on one page

Using more than one <h1> is allowed by the HTML specification, but is not considered a best practice. Using only one <h1> is beneficial for screenreader users.

The HTML specification includes the concept of an outline formed by the use of <section> elements. If this were implemented it would enable the use of multiple <h1> elements, giving user agents—including screen readers—a way to understand that an <h1> nested inside a defined section is a subheading. This functionality has never been implemented; therefore it is important to use your headings to describe the outline of your document. 

Notes:
  * Heading information can be used by user agents to construct a table of contents for a
    document automatically.
  * Avoid using heading elements to resize text. Instead, use the CSS font-size property.
  * Avoid skipping heading levels: always start from <h1>, followed by <h2> and so on.
  * Use only one <h1> per page or view. It should concisely describe the overall purpose of the
    content.
  * The align attribute is obsolete; don't use it.

Português:

Os elementos HTML <h1> a <h6> representam seis níveis de cabeçalho, onde, <h1> é o nível mais alto e <h6> o nível mais baixo.

Múltiplos elementos <h1> em uma página

O uso de mais de um <h1> é permitido pela especificação HTML, mas não é considerado uma prática recomendada. Usar apenas um <h1> é benéfico para usuários de leitores de tela.

A especificação HTML inclui o conceito de contorno formado pelo uso de elementos <section>. Se isso fosse implementado, permitiria o uso de vários elementos <h1>, dando aos agentes do usuário – incluindo leitores de tela – uma maneira de entender que um <h1> aninhado dentro de uma seção definida é um subtítulo. Essa funcionalidade nunca foi implementada; portanto, é importante usar seus títulos para descrever o esboço do seu documento. 

Notas:
  * As informações de cabeçalho podem ser usadas por agentes de usuário para construir
    automaticamente um índice para um documento.
  * Evite usar elementos de título para redimensionar o texto. Em vez disso, use a propriedade
    CSS font-size.
  * Evite pular níveis de título: sempre comece de <h1>, seguido de <h2> e assim por diante.
  * Use apenas um <h1> por página ou visualização. Deve descrever de forma concisa o propósito
    geral do conteúdo.
  * O atributo align está obsoleto; não o use.

func (*TagH2) AccessKey 

func (e *TagH2) AccessKey(key string) (ref *TagH2)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagH2) AddListener 

func (e *TagH2) AddListener(eventType interface{}, manager mouse.SimpleManager) (ref *TagH2)

AddListener

English: 

Associates a function with an event.

 Example:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

Português: 

Associa uma função a um evento.

 Exemplo:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

func (*TagH2) AddPointsToEasingTween 

func (e *TagH2) AddPointsToEasingTween(algorithmRef algorithm.CurveInterface) (ref *TagH2)

AddPointsToEasingTween

English: 

This function returns an easing tween function compatible with the easing onStepFunc() function in order to use the
points generated by the line algorithms as a reference to the movement.

 Note:
   * The 'onStartValue' and 'onEndValue' parameters must have the values 0 and 10000.
     Example:
       factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

Português: 

Esta função retorna uma função easing tween compatível com a função onStepFunc() do easing de modo a usar os pontos
gerados pelos algoritmos de linha como referência ao movimento.

 Nota:
   * O parâmetros 'onStartValue' e 'onEndValue' devem, obrigatoriamente, ter os valores 0 e 10000.
     Exemplo:
       factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

func (*TagH2) Append 

func (e *TagH2) Append(elements ...Compatible) (ref *TagH2)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

fixme: fazer append() assim em todas as tags html, exceto svg

func (*TagH2) AppendById 

func (e *TagH2) AppendById(appendId string) (ref *TagH2)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagH2) AppendToStage 

func (e *TagH2) AppendToStage() (ref *TagH2)

AppendToStage

English: 

Adds a node to the end of the list of children in the main document body. If the node already
exists somewhere in the document, it is removed from its current parent node before being added
to the main document.

Português: 

Adiciona um nó ao final da lista de filhos do corpo do documento principal. Se o nó já existir
em alguma parte do documento, ele é removido de seu nó pai atual antes de ser adicionado ao
documento principal.

todo:https://developer.mozilla.org/en-US/docs/Web/API/Document/createDocumentFragment todo: appendMany()

func (*TagH2) Autofocus 

func (e *TagH2) Autofocus(autofocus bool) (ref *TagH2)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagH2) Class 

func (e *TagH2) Class(class ...string) (ref *TagH2)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagH2) ContentEditable 

func (e *TagH2) ContentEditable(editable bool) (ref *TagH2)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagH2) CreateElement 

func (e *TagH2) CreateElement() (ref *TagH2)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagH2) Data 

func (e *TagH2) Data(data map[string]string) (ref *TagH2)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagH2) Dir 

func (e *TagH2) Dir(dir Dir) (ref *TagH2)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagH2) DragStart 

func (e *TagH2) DragStart() (ref *TagH2)

DragStart

English: 

Mouse drag function.

 Example:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

Português: 

Função de arrastar com o mouse.

 Exemplo:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

func (*TagH2) DragStop 

func (e *TagH2) DragStop() (ref *TagH2)

DragStop

English: 

Stop mouse drag functionality.

 Example:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

   go func() {
     time.Sleep(10 * time.Second)
     div.DragStop()
   }()

Português: 

Para a funcionalidade de arrastar com o mouse.

 Exemplo:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

   go func() {
     time.Sleep(10 * time.Second)
     div.DragStop()
   }()

func (*TagH2) Draggable 

func (e *TagH2) Draggable(draggable Draggable) (ref *TagH2)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagH2) EasingTweenWalkingAndRotateIntoPoints 

func (e *TagH2) EasingTweenWalkingAndRotateIntoPoints() (function func(forTenThousand, percent float64, args interface{}))

EasingTweenWalkingAndRotateIntoPoints

English: 

Moves the element on the line added by the AddPointsToEasingTween() function and adjusts the rotation of the
element with respect to the next point.

This function returns a second function compatible with the easing tween's onStepFunc() function. 

Note:
  * Use the RotateDelta() function to adjust the starting angle;
  * The 'onStartValue' and 'onEndValue' parameters must have the values 0 and 10000.
    Example:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

Português: 

Desloca o elemento na linha adicionada pela função AddPointsToEasingTween() e ajusta a rotação do elemento em relação ao próximo ponto.

Esta função retorna uma segunda função compatível com a função onStepFunc() do easing tween. 

Nota:
  * Use a função RotateDelta() para ajustar o ângulo inicial;
  * O parâmetros 'onStartValue' e 'onEndValue' devem, obrigatoriamente, ter os valores 0 e 10000.
    Exemplo:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

func (*TagH2) EasingTweenWalkingIntoPoints 

func (e *TagH2) EasingTweenWalkingIntoPoints() (function func(percent, p float64, args interface{}))

EasingTweenWalkingIntoPoints

English: 

Moves the element on the line added by the AddPointsToEasingTween() function.

This function returns a second function compatible with the easing tween's onStepFunc() function. 

Note:
  * The 'onStartValue' and 'onEndValue' parameters must have the values 0 and 10000.
    Example:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

Português: 

Desloca o elemento na linha adicionada pela função AddPointsToEasingTween().

Esta função retorna uma segunda função compatível com a função onStepFunc() do easing tween. 

Nota:
  * O parâmetros 'onStartValue' e 'onEndValue' devem, obrigatoriamente, ter os valores 0 e 10000.
    Exemplo:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

func (*TagH2) EnterKeyHint 

func (e *TagH2) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagH2)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagH2) Get 

func (e *TagH2) Get() (el js.Value)

func (*TagH2) GetBottom 

func (e *TagH2) GetBottom() (bottom int)

GetBottom

English: 

It is the same as y + height.

Português: 

É o mesmo que y + Height.

func (*TagH2) GetLeft 

func (e *TagH2) GetLeft() (left int)

GetLeft

English: 

Same as GetY() function, returns the y position of the element.

Português: 

O mesmo que a função GetY(), retorna a posição y do elemento.

func (*TagH2) GetRight 

func (e *TagH2) GetRight() (right int)

GetRight

English: 

It is the same as x + width.

Português: 

É o mesmo que x + width.

func (*TagH2) GetRotateDelta 

func (e *TagH2) GetRotateDelta() (delta float64)

GetRotateDelta

English: 

Returns the rotation adjustment angle, i.e. Rotate() = angle + delta.

 Output:
   angle: delta, object rotation adjustment angle.

Português: 

Retorna o ângulo de ajuste da rotação, ou seja, Rotate() = angle + delta.

 Saída:
   angle: delta, ângulo de ajuste da rotação do objeto.

func (*TagH2) GetTop 

func (e *TagH2) GetTop() (top int)

GetTop

English: 

Same as GetX() function, returns the x position of the element.

Português: 

O mesmo que a função GetX(), retorna a posição x do elemento.

func (*TagH2) GetX 

func (e *TagH2) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagH2) GetXY 

func (e *TagH2) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagH2) GetY 

func (e *TagH2) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagH2) Hidden 

func (e *TagH2) Hidden() (ref *TagH2)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagH2) Html 

func (e *TagH2) Html(value string) (ref *TagH2)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagH2) Id 

func (e *TagH2) Id(id string) (ref *TagH2)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagH2) Init 

func (e *TagH2) Init() (ref *TagH2)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagH2) InputMode 

func (e *TagH2) InputMode(inputMode InputMode) (ref *TagH2)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagH2) Is 

func (e *TagH2) Is(is string) (ref *TagH2)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagH2) ItemDrop 

func (e *TagH2) ItemDrop(itemprop string) (ref *TagH2)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagH2) ItemId 

func (e *TagH2) ItemId(id string) (ref *TagH2)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagH2) ItemRef 

func (e *TagH2) ItemRef(itemref string) (ref *TagH2)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagH2) ItemType 

func (e *TagH2) ItemType(itemType string) (ref *TagH2)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagH2) Lang 

func (e *TagH2) Lang(language Language) (ref *TagH2)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagH2) Mouse 

func (e *TagH2) Mouse(value mouse.CursorType) (ref *TagH2)

Mouse

English: 

Defines the shape of the mouse pointer.

 Input:
   value: mouse pointer shape.
     Example: SetMouse(mouse.KCursorCell) // Use mouse.K... and let autocomplete do the
              rest

Português: 

Define o formato do ponteiro do mouse.

 Entrada:
   value: formato do ponteiro do mouse.
     Exemplo: SetMouse(mouse.KCursorCell) // Use mouse.K... e deixe o autocompletar fazer
              o resto

func (*TagH2) Nonce 

func (e *TagH2) Nonce(part ...string) (ref *TagH2)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagH2) RemoveListener 

func (e *TagH2) RemoveListener(eventType interface{}) (ref *TagH2)

RemoveListener

English: 

Remove the function associated with the event

 Example:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

Português: 

Remove a função associada com o evento.

 Exemplo:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

func (*TagH2) Rotate 

func (e *TagH2) Rotate(angle float64) (ref *TagH2)

Rotate

English: 

Defines a transformation that rotates an element around a fixed point on the 2D plane, without deforming it.

 Input:
   angle: representing the angle of the rotation. The direction of rotation depends on the writing direction.
   In a left-to-right context, a positive angle denotes a clockwise rotation, a negative angle a counter-clockwise
   one.
   In a right-to-left context, a positive angle denotes a counter-clockwise rotation, a negative angle a clockwise
   one.

Português: 

Define uma transformação que gira um elemento em torno de um ponto fixo no plano 2D, sem deformá-lo.

 Entrada:
   angle: representando o ângulo de rotação. O sentido de rotação depende do sentido de escrita.
   Em um contexto da esquerda para a direita, um ângulo positivo denota uma rotação no sentido horário, um ângulo
   negativo no sentido anti-horário.
   Em um contexto da direita para a esquerda, um ângulo positivo denota uma rotação no sentido anti-horário, um
   ângulo negativo denota uma rotação no sentido horário.

func (*TagH2) RotateDelta 

func (e *TagH2) RotateDelta(delta float64) (ref *TagH2)

RotateDelta

English: 

Used in conjunction with the Rotate() function, sets the rotation adjustment angle, ie Rotate() = angle + delta.

 Input:
   angle: delta, object rotation adjustment angle.

Português: 

Usada em conjunto com a função Rotate(), define o ângulo de ajuste da rotação, ou seja, Rotate() = angle + delta.

 Entrada:
   angle: delta, ângulo de ajuste da rotação do objeto.

func (*TagH2) SetDeltaX 

func (e *TagH2) SetDeltaX(delta int) (ref *TagH2)

SetDeltaX

English: 

Additional value added in the SetX() function: (x = x + deltaMovieX) and subtracted in the
GetX() function: (x = x - deltaMovieX).

Português: 

Valor adicional adicionado na função SetX(): (x = x + deltaMovieX)  e subtraído na função
GetX(): (x = x - deltaMovieX).

func (*TagH2) SetDeltaY 

func (e *TagH2) SetDeltaY(delta int) (ref *TagH2)

SetDeltaY

English: 

Additional value added in the SetY() function: (y = y + deltaMovieY) and subtracted in the
GetY() function: (y = y - deltaMovieY).

Português: 

Valor adicional adicionado na função SetY(): (y = y + deltaMovieY)  e subtraído na função
GetX(): (y = y - deltaMovieY).

func (*TagH2) SetX 

func (e *TagH2) SetX(x int) (ref *TagH2)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagH2) SetXY 

func (e *TagH2) SetXY(x, y int) (ref *TagH2)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagH2) SetY 

func (e *TagH2) SetY(y int) (ref *TagH2)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagH2) Slot 

func (e *TagH2) Slot(slot string) (ref *TagH2)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagH2) Spellcheck 

func (e *TagH2) Spellcheck(spell bool) (ref *TagH2)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagH2) Style 

func (e *TagH2) Style(style string) (ref *TagH2)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagH2) TabIndex 

func (e *TagH2) TabIndex(index int) (ref *TagH2)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagH2) Text 

func (e *TagH2) Text(value string) (ref *TagH2)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagH2) Title 

func (e *TagH2) Title(title string) (ref *TagH2)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagH2) Translate 

func (e *TagH2) Translate(translate Translate) (ref *TagH2)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

type TagH3 

type TagH3 struct {
	// contains filtered or unexported fields
}

TagH3

English:

The <h1> to <h6> HTML elements represent six levels of section headings. <h1> is the highest section level and <h6> is the lowest.

Multiple <h1> elements on one page

Using more than one <h1> is allowed by the HTML specification, but is not considered a best practice. Using only one <h1> is beneficial for screenreader users.

The HTML specification includes the concept of an outline formed by the use of <section> elements. If this were implemented it would enable the use of multiple <h1> elements, giving user agents—including screen readers—a way to understand that an <h1> nested inside a defined section is a subheading. This functionality has never been implemented; therefore it is important to use your headings to describe the outline of your document. 

Notes:
  * Heading information can be used by user agents to construct a table of contents for a
    document automatically.
  * Avoid using heading elements to resize text. Instead, use the CSS font-size property.
  * Avoid skipping heading levels: always start from <h1>, followed by <h2> and so on.
  * Use only one <h1> per page or view. It should concisely describe the overall purpose of the
    content.
  * The align attribute is obsolete; don't use it.

Português:

Os elementos HTML <h1> a <h6> representam seis níveis de cabeçalho, onde, <h1> é o nível mais alto e <h6> o nível mais baixo.

Múltiplos elementos <h1> em uma página

O uso de mais de um <h1> é permitido pela especificação HTML, mas não é considerado uma prática recomendada. Usar apenas um <h1> é benéfico para usuários de leitores de tela.

A especificação HTML inclui o conceito de contorno formado pelo uso de elementos <section>. Se isso fosse implementado, permitiria o uso de vários elementos <h1>, dando aos agentes do usuário – incluindo leitores de tela – uma maneira de entender que um <h1> aninhado dentro de uma seção definida é um subtítulo. Essa funcionalidade nunca foi implementada; portanto, é importante usar seus títulos para descrever o esboço do seu documento. 

Notas:
  * As informações de cabeçalho podem ser usadas por agentes de usuário para construir
    automaticamente um índice para um documento.
  * Evite usar elementos de título para redimensionar o texto. Em vez disso, use a propriedade
    CSS font-size.
  * Evite pular níveis de título: sempre comece de <h1>, seguido de <h2> e assim por diante.
  * Use apenas um <h1> por página ou visualização. Deve descrever de forma concisa o propósito
    geral do conteúdo.
  * O atributo align está obsoleto; não o use.

func (*TagH3) AccessKey 

func (e *TagH3) AccessKey(key string) (ref *TagH3)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagH3) AddListener 

func (e *TagH3) AddListener(eventType interface{}, manager mouse.SimpleManager) (ref *TagH3)

AddListener

English: 

Associates a function with an event.

 Example:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

Português: 

Associa uma função a um evento.

 Exemplo:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

func (*TagH3) AddPointsToEasingTween 

func (e *TagH3) AddPointsToEasingTween(algorithmRef algorithm.CurveInterface) (ref *TagH3)

AddPointsToEasingTween

English: 

This function returns an easing tween function compatible with the easing onStepFunc() function in order to use the
points generated by the line algorithms as a reference to the movement.

 Note:
   * The 'onStartValue' and 'onEndValue' parameters must have the values 0 and 10000.
     Example:
       factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

Português: 

Esta função retorna uma função easing tween compatível com a função onStepFunc() do easing de modo a usar os pontos
gerados pelos algoritmos de linha como referência ao movimento.

 Nota:
   * O parâmetros 'onStartValue' e 'onEndValue' devem, obrigatoriamente, ter os valores 0 e 10000.
     Exemplo:
       factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

func (*TagH3) Append 

func (e *TagH3) Append(elements ...Compatible) (ref *TagH3)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

fixme: fazer append() assim em todas as tags html, exceto svg

func (*TagH3) AppendById 

func (e *TagH3) AppendById(appendId string) (ref *TagH3)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagH3) AppendToStage 

func (e *TagH3) AppendToStage() (ref *TagH3)

AppendToStage

English: 

Adds a node to the end of the list of children in the main document body. If the node already
exists somewhere in the document, it is removed from its current parent node before being added
to the main document.

Português: 

Adiciona um nó ao final da lista de filhos do corpo do documento principal. Se o nó já existir
em alguma parte do documento, ele é removido de seu nó pai atual antes de ser adicionado ao
documento principal.

todo:https://developer.mozilla.org/en-US/docs/Web/API/Document/createDocumentFragment todo: appendMany()

func (*TagH3) Autofocus 

func (e *TagH3) Autofocus(autofocus bool) (ref *TagH3)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagH3) Class 

func (e *TagH3) Class(class ...string) (ref *TagH3)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagH3) ContentEditable 

func (e *TagH3) ContentEditable(editable bool) (ref *TagH3)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagH3) CreateElement 

func (e *TagH3) CreateElement() (ref *TagH3)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagH3) Data 

func (e *TagH3) Data(data map[string]string) (ref *TagH3)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagH3) Dir 

func (e *TagH3) Dir(dir Dir) (ref *TagH3)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagH3) DragStart 

func (e *TagH3) DragStart() (ref *TagH3)

DragStart

English: 

Mouse drag function.

 Example:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

Português: 

Função de arrastar com o mouse.

 Exemplo:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

func (*TagH3) DragStop 

func (e *TagH3) DragStop() (ref *TagH3)

DragStop

English: 

Stop mouse drag functionality.

 Example:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

   go func() {
     time.Sleep(10 * time.Second)
     div.DragStop()
   }()

Português: 

Para a funcionalidade de arrastar com o mouse.

 Exemplo:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

   go func() {
     time.Sleep(10 * time.Second)
     div.DragStop()
   }()

func (*TagH3) Draggable 

func (e *TagH3) Draggable(draggable Draggable) (ref *TagH3)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagH3) EasingTweenWalkingAndRotateIntoPoints 

func (e *TagH3) EasingTweenWalkingAndRotateIntoPoints() (function func(forTenThousand, percent float64, args interface{}))

EasingTweenWalkingAndRotateIntoPoints

English: 

Moves the element on the line added by the AddPointsToEasingTween() function and adjusts the rotation of the
element with respect to the next point.

This function returns a second function compatible with the easing tween's onStepFunc() function. 

Note:
  * Use the RotateDelta() function to adjust the starting angle;
  * The 'onStartValue' and 'onEndValue' parameters must have the values 0 and 10000.
    Example:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

Português: 

Desloca o elemento na linha adicionada pela função AddPointsToEasingTween() e ajusta a rotação do elemento em relação ao próximo ponto.

Esta função retorna uma segunda função compatível com a função onStepFunc() do easing tween. 

Nota:
  * Use a função RotateDelta() para ajustar o ângulo inicial;
  * O parâmetros 'onStartValue' e 'onEndValue' devem, obrigatoriamente, ter os valores 0 e 10000.
    Exemplo:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

func (*TagH3) EasingTweenWalkingIntoPoints 

func (e *TagH3) EasingTweenWalkingIntoPoints() (function func(percent, p float64, args interface{}))

EasingTweenWalkingIntoPoints

English: 

Moves the element on the line added by the AddPointsToEasingTween() function.

This function returns a second function compatible with the easing tween's onStepFunc() function. 

Note:
  * The 'onStartValue' and 'onEndValue' parameters must have the values 0 and 10000.
    Example:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

Português: 

Desloca o elemento na linha adicionada pela função AddPointsToEasingTween().

Esta função retorna uma segunda função compatível com a função onStepFunc() do easing tween. 

Nota:
  * O parâmetros 'onStartValue' e 'onEndValue' devem, obrigatoriamente, ter os valores 0 e 10000.
    Exemplo:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

func (*TagH3) EnterKeyHint 

func (e *TagH3) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagH3)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagH3) Get 

func (e *TagH3) Get() (el js.Value)

func (*TagH3) GetBottom 

func (e *TagH3) GetBottom() (bottom int)

GetBottom

English: 

It is the same as y + height.

Português: 

É o mesmo que y + Height.

func (*TagH3) GetLeft 

func (e *TagH3) GetLeft() (left int)

GetLeft

English: 

Same as GetY() function, returns the y position of the element.

Português: 

O mesmo que a função GetY(), retorna a posição y do elemento.

func (*TagH3) GetRight 

func (e *TagH3) GetRight() (right int)

GetRight

English: 

It is the same as x + width.

Português: 

É o mesmo que x + width.

func (*TagH3) GetRotateDelta 

func (e *TagH3) GetRotateDelta() (delta float64)

GetRotateDelta

English: 

Returns the rotation adjustment angle, i.e. Rotate() = angle + delta.

 Output:
   angle: delta, object rotation adjustment angle.

Português: 

Retorna o ângulo de ajuste da rotação, ou seja, Rotate() = angle + delta.

 Saída:
   angle: delta, ângulo de ajuste da rotação do objeto.

func (*TagH3) GetTop 

func (e *TagH3) GetTop() (top int)

GetTop

English: 

Same as GetX() function, returns the x position of the element.

Português: 

O mesmo que a função GetX(), retorna a posição x do elemento.

func (*TagH3) GetX 

func (e *TagH3) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagH3) GetXY 

func (e *TagH3) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagH3) GetY 

func (e *TagH3) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagH3) Hidden 

func (e *TagH3) Hidden() (ref *TagH3)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagH3) Html 

func (e *TagH3) Html(value string) (ref *TagH3)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagH3) Id 

func (e *TagH3) Id(id string) (ref *TagH3)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagH3) Init 

func (e *TagH3) Init() (ref *TagH3)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagH3) InputMode 

func (e *TagH3) InputMode(inputMode InputMode) (ref *TagH3)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagH3) Is 

func (e *TagH3) Is(is string) (ref *TagH3)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagH3) ItemDrop 

func (e *TagH3) ItemDrop(itemprop string) (ref *TagH3)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagH3) ItemId 

func (e *TagH3) ItemId(id string) (ref *TagH3)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagH3) ItemRef 

func (e *TagH3) ItemRef(itemref string) (ref *TagH3)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagH3) ItemType 

func (e *TagH3) ItemType(itemType string) (ref *TagH3)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagH3) Lang 

func (e *TagH3) Lang(language Language) (ref *TagH3)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagH3) Mouse 

func (e *TagH3) Mouse(value mouse.CursorType) (ref *TagH3)

Mouse

English: 

Defines the shape of the mouse pointer.

 Input:
   value: mouse pointer shape.
     Example: SetMouse(mouse.KCursorCell) // Use mouse.K... and let autocomplete do the
              rest

Português: 

Define o formato do ponteiro do mouse.

 Entrada:
   value: formato do ponteiro do mouse.
     Exemplo: SetMouse(mouse.KCursorCell) // Use mouse.K... e deixe o autocompletar fazer
              o resto

func (*TagH3) Nonce 

func (e *TagH3) Nonce(part ...string) (ref *TagH3)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagH3) RemoveListener 

func (e *TagH3) RemoveListener(eventType interface{}) (ref *TagH3)

RemoveListener

English: 

Remove the function associated with the event

 Example:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

Português: 

Remove a função associada com o evento.

 Exemplo:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

func (*TagH3) Rotate 

func (e *TagH3) Rotate(angle float64) (ref *TagH3)

Rotate

English: 

Defines a transformation that rotates an element around a fixed point on the 2D plane, without deforming it.

 Input:
   angle: representing the angle of the rotation. The direction of rotation depends on the writing direction.
   In a left-to-right context, a positive angle denotes a clockwise rotation, a negative angle a counter-clockwise
   one.
   In a right-to-left context, a positive angle denotes a counter-clockwise rotation, a negative angle a clockwise
   one.

Português: 

Define uma transformação que gira um elemento em torno de um ponto fixo no plano 2D, sem deformá-lo.

 Entrada:
   angle: representando o ângulo de rotação. O sentido de rotação depende do sentido de escrita.
   Em um contexto da esquerda para a direita, um ângulo positivo denota uma rotação no sentido horário, um ângulo
   negativo no sentido anti-horário.
   Em um contexto da direita para a esquerda, um ângulo positivo denota uma rotação no sentido anti-horário, um
   ângulo negativo denota uma rotação no sentido horário.

func (*TagH3) RotateDelta 

func (e *TagH3) RotateDelta(delta float64) (ref *TagH3)

RotateDelta

English: 

Used in conjunction with the Rotate() function, sets the rotation adjustment angle, ie Rotate() = angle + delta.

 Input:
   angle: delta, object rotation adjustment angle.

Português: 

Usada em conjunto com a função Rotate(), define o ângulo de ajuste da rotação, ou seja, Rotate() = angle + delta.

 Entrada:
   angle: delta, ângulo de ajuste da rotação do objeto.

func (*TagH3) SetDeltaX 

func (e *TagH3) SetDeltaX(delta int) (ref *TagH3)

SetDeltaX

English: 

Additional value added in the SetX() function: (x = x + deltaMovieX) and subtracted in the
GetX() function: (x = x - deltaMovieX).

Português: 

Valor adicional adicionado na função SetX(): (x = x + deltaMovieX)  e subtraído na função
GetX(): (x = x - deltaMovieX).

func (*TagH3) SetDeltaY 

func (e *TagH3) SetDeltaY(delta int) (ref *TagH3)

SetDeltaY

English: 

Additional value added in the SetY() function: (y = y + deltaMovieY) and subtracted in the
GetY() function: (y = y - deltaMovieY).

Português: 

Valor adicional adicionado na função SetY(): (y = y + deltaMovieY)  e subtraído na função
GetX(): (y = y - deltaMovieY).

func (*TagH3) SetX 

func (e *TagH3) SetX(x int) (ref *TagH3)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagH3) SetXY 

func (e *TagH3) SetXY(x, y int) (ref *TagH3)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagH3) SetY 

func (e *TagH3) SetY(y int) (ref *TagH3)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagH3) Slot 

func (e *TagH3) Slot(slot string) (ref *TagH3)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagH3) Spellcheck 

func (e *TagH3) Spellcheck(spell bool) (ref *TagH3)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagH3) Style 

func (e *TagH3) Style(style string) (ref *TagH3)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagH3) TabIndex 

func (e *TagH3) TabIndex(index int) (ref *TagH3)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagH3) Text 

func (e *TagH3) Text(value string) (ref *TagH3)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagH3) Title 

func (e *TagH3) Title(title string) (ref *TagH3)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagH3) Translate 

func (e *TagH3) Translate(translate Translate) (ref *TagH3)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

type TagH4 

type TagH4 struct {
	// contains filtered or unexported fields
}

TagH4

English:

The <h1> to <h6> HTML elements represent six levels of section headings. <h1> is the highest section level and <h6> is the lowest.

Multiple <h1> elements on one page

Using more than one <h1> is allowed by the HTML specification, but is not considered a best practice. Using only one <h1> is beneficial for screenreader users.

The HTML specification includes the concept of an outline formed by the use of <section> elements. If this were implemented it would enable the use of multiple <h1> elements, giving user agents—including screen readers—a way to understand that an <h1> nested inside a defined section is a subheading. This functionality has never been implemented; therefore it is important to use your headings to describe the outline of your document. 

Notes:
  * Heading information can be used by user agents to construct a table of contents for a
    document automatically.
  * Avoid using heading elements to resize text. Instead, use the CSS font-size property.
  * Avoid skipping heading levels: always start from <h1>, followed by <h2> and so on.
  * Use only one <h1> per page or view. It should concisely describe the overall purpose of the
    content.
  * The align attribute is obsolete; don't use it.

Português:

Os elementos HTML <h1> a <h6> representam seis níveis de cabeçalho, onde, <h1> é o nível mais alto e <h6> o nível mais baixo.

Múltiplos elementos <h1> em uma página

O uso de mais de um <h1> é permitido pela especificação HTML, mas não é considerado uma prática recomendada. Usar apenas um <h1> é benéfico para usuários de leitores de tela.

A especificação HTML inclui o conceito de contorno formado pelo uso de elementos <section>. Se isso fosse implementado, permitiria o uso de vários elementos <h1>, dando aos agentes do usuário – incluindo leitores de tela – uma maneira de entender que um <h1> aninhado dentro de uma seção definida é um subtítulo. Essa funcionalidade nunca foi implementada; portanto, é importante usar seus títulos para descrever o esboço do seu documento. 

Notas:
  * As informações de cabeçalho podem ser usadas por agentes de usuário para construir
    automaticamente um índice para um documento.
  * Evite usar elementos de título para redimensionar o texto. Em vez disso, use a propriedade
    CSS font-size.
  * Evite pular níveis de título: sempre comece de <h1>, seguido de <h2> e assim por diante.
  * Use apenas um <h1> por página ou visualização. Deve descrever de forma concisa o propósito
    geral do conteúdo.
  * O atributo align está obsoleto; não o use.

func (*TagH4) AccessKey 

func (e *TagH4) AccessKey(key string) (ref *TagH4)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagH4) AddListener 

func (e *TagH4) AddListener(eventType interface{}, manager mouse.SimpleManager) (ref *TagH4)

AddListener

English: 

Associates a function with an event.

 Example:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

Português: 

Associa uma função a um evento.

 Exemplo:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

func (*TagH4) AddPointsToEasingTween 

func (e *TagH4) AddPointsToEasingTween(algorithmRef algorithm.CurveInterface) (ref *TagH4)

AddPointsToEasingTween

English: 

This function returns an easing tween function compatible with the easing onStepFunc() function in order to use the
points generated by the line algorithms as a reference to the movement.

 Note:
   * The 'onStartValue' and 'onEndValue' parameters must have the values 0 and 10000.
     Example:
       factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

Português: 

Esta função retorna uma função easing tween compatível com a função onStepFunc() do easing de modo a usar os pontos
gerados pelos algoritmos de linha como referência ao movimento.

 Nota:
   * O parâmetros 'onStartValue' e 'onEndValue' devem, obrigatoriamente, ter os valores 0 e 10000.
     Exemplo:
       factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

func (*TagH4) Append 

func (e *TagH4) Append(elements ...Compatible) (ref *TagH4)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

fixme: fazer append() assim em todas as tags html, exceto svg

func (*TagH4) AppendById 

func (e *TagH4) AppendById(appendId string) (ref *TagH4)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagH4) AppendToStage 

func (e *TagH4) AppendToStage() (ref *TagH4)

AppendToStage

English: 

Adds a node to the end of the list of children in the main document body. If the node already
exists somewhere in the document, it is removed from its current parent node before being added
to the main document.

Português: 

Adiciona um nó ao final da lista de filhos do corpo do documento principal. Se o nó já existir
em alguma parte do documento, ele é removido de seu nó pai atual antes de ser adicionado ao
documento principal.

todo:https://developer.mozilla.org/en-US/docs/Web/API/Document/createDocumentFragment todo: appendMany()

func (*TagH4) Autofocus 

func (e *TagH4) Autofocus(autofocus bool) (ref *TagH4)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagH4) Class 

func (e *TagH4) Class(class ...string) (ref *TagH4)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagH4) ContentEditable 

func (e *TagH4) ContentEditable(editable bool) (ref *TagH4)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagH4) CreateElement 

func (e *TagH4) CreateElement() (ref *TagH4)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagH4) Data 

func (e *TagH4) Data(data map[string]string) (ref *TagH4)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagH4) Dir 

func (e *TagH4) Dir(dir Dir) (ref *TagH4)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagH4) DragStart 

func (e *TagH4) DragStart() (ref *TagH4)

DragStart

English: 

Mouse drag function.

 Example:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

Português: 

Função de arrastar com o mouse.

 Exemplo:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

func (*TagH4) DragStop 

func (e *TagH4) DragStop() (ref *TagH4)

DragStop

English: 

Stop mouse drag functionality.

 Example:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

   go func() {
     time.Sleep(10 * time.Second)
     div.DragStop()
   }()

Português: 

Para a funcionalidade de arrastar com o mouse.

 Exemplo:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

   go func() {
     time.Sleep(10 * time.Second)
     div.DragStop()
   }()

func (*TagH4) Draggable 

func (e *TagH4) Draggable(draggable Draggable) (ref *TagH4)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagH4) EasingTweenWalkingAndRotateIntoPoints 

func (e *TagH4) EasingTweenWalkingAndRotateIntoPoints() (function func(forTenThousand, percent float64, args interface{}))

EasingTweenWalkingAndRotateIntoPoints

English: 

Moves the element on the line added by the AddPointsToEasingTween() function and adjusts the rotation of the
element with respect to the next point.

This function returns a second function compatible with the easing tween's onStepFunc() function. 

Note:
  * Use the RotateDelta() function to adjust the starting angle;
  * The 'onStartValue' and 'onEndValue' parameters must have the values 0 and 10000.
    Example:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

Português: 

Desloca o elemento na linha adicionada pela função AddPointsToEasingTween() e ajusta a rotação do elemento em relação ao próximo ponto.

Esta função retorna uma segunda função compatível com a função onStepFunc() do easing tween. 

Nota:
  * Use a função RotateDelta() para ajustar o ângulo inicial;
  * O parâmetros 'onStartValue' e 'onEndValue' devem, obrigatoriamente, ter os valores 0 e 10000.
    Exemplo:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

func (*TagH4) EasingTweenWalkingIntoPoints 

func (e *TagH4) EasingTweenWalkingIntoPoints() (function func(percent, p float64, args interface{}))

EasingTweenWalkingIntoPoints

English: 

Moves the element on the line added by the AddPointsToEasingTween() function.

This function returns a second function compatible with the easing tween's onStepFunc() function. 

Note:
  * The 'onStartValue' and 'onEndValue' parameters must have the values 0 and 10000.
    Example:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

Português: 

Desloca o elemento na linha adicionada pela função AddPointsToEasingTween().

Esta função retorna uma segunda função compatível com a função onStepFunc() do easing tween. 

Nota:
  * O parâmetros 'onStartValue' e 'onEndValue' devem, obrigatoriamente, ter os valores 0 e 10000.
    Exemplo:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

func (*TagH4) EnterKeyHint 

func (e *TagH4) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagH4)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagH4) Get 

func (e *TagH4) Get() (el js.Value)

func (*TagH4) GetBottom 

func (e *TagH4) GetBottom() (bottom int)

GetBottom

English: 

It is the same as y + height.

Português: 

É o mesmo que y + Height.

func (*TagH4) GetLeft 

func (e *TagH4) GetLeft() (left int)

GetLeft

English: 

Same as GetY() function, returns the y position of the element.

Português: 

O mesmo que a função GetY(), retorna a posição y do elemento.

func (*TagH4) GetRight 

func (e *TagH4) GetRight() (right int)

GetRight

English: 

It is the same as x + width.

Português: 

É o mesmo que x + width.

func (*TagH4) GetRotateDelta 

func (e *TagH4) GetRotateDelta() (delta float64)

GetRotateDelta

English: 

Returns the rotation adjustment angle, i.e. Rotate() = angle + delta.

 Output:
   angle: delta, object rotation adjustment angle.

Português: 

Retorna o ângulo de ajuste da rotação, ou seja, Rotate() = angle + delta.

 Saída:
   angle: delta, ângulo de ajuste da rotação do objeto.

func (*TagH4) GetTop 

func (e *TagH4) GetTop() (top int)

GetTop

English: 

Same as GetX() function, returns the x position of the element.

Português: 

O mesmo que a função GetX(), retorna a posição x do elemento.

func (*TagH4) GetX 

func (e *TagH4) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagH4) GetXY 

func (e *TagH4) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagH4) GetY 

func (e *TagH4) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagH4) Hidden 

func (e *TagH4) Hidden() (ref *TagH4)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagH4) Html 

func (e *TagH4) Html(value string) (ref *TagH4)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagH4) Id 

func (e *TagH4) Id(id string) (ref *TagH4)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagH4) Init 

func (e *TagH4) Init() (ref *TagH4)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagH4) InputMode 

func (e *TagH4) InputMode(inputMode InputMode) (ref *TagH4)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagH4) Is 

func (e *TagH4) Is(is string) (ref *TagH4)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagH4) ItemDrop 

func (e *TagH4) ItemDrop(itemprop string) (ref *TagH4)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagH4) ItemId 

func (e *TagH4) ItemId(id string) (ref *TagH4)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagH4) ItemRef 

func (e *TagH4) ItemRef(itemref string) (ref *TagH4)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagH4) ItemType 

func (e *TagH4) ItemType(itemType string) (ref *TagH4)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagH4) Lang 

func (e *TagH4) Lang(language Language) (ref *TagH4)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagH4) Mouse 

func (e *TagH4) Mouse(value mouse.CursorType) (ref *TagH4)

Mouse

English: 

Defines the shape of the mouse pointer.

 Input:
   value: mouse pointer shape.
     Example: SetMouse(mouse.KCursorCell) // Use mouse.K... and let autocomplete do the
              rest

Português: 

Define o formato do ponteiro do mouse.

 Entrada:
   value: formato do ponteiro do mouse.
     Exemplo: SetMouse(mouse.KCursorCell) // Use mouse.K... e deixe o autocompletar fazer
              o resto

func (*TagH4) Nonce 

func (e *TagH4) Nonce(part ...string) (ref *TagH4)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagH4) RemoveListener 

func (e *TagH4) RemoveListener(eventType interface{}) (ref *TagH4)

RemoveListener

English: 

Remove the function associated with the event

 Example:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

Português: 

Remove a função associada com o evento.

 Exemplo:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

func (*TagH4) Rotate 

func (e *TagH4) Rotate(angle float64) (ref *TagH4)

Rotate

English: 

Defines a transformation that rotates an element around a fixed point on the 2D plane, without deforming it.

 Input:
   angle: representing the angle of the rotation. The direction of rotation depends on the writing direction.
   In a left-to-right context, a positive angle denotes a clockwise rotation, a negative angle a counter-clockwise
   one.
   In a right-to-left context, a positive angle denotes a counter-clockwise rotation, a negative angle a clockwise
   one.

Português: 

Define uma transformação que gira um elemento em torno de um ponto fixo no plano 2D, sem deformá-lo.

 Entrada:
   angle: representando o ângulo de rotação. O sentido de rotação depende do sentido de escrita.
   Em um contexto da esquerda para a direita, um ângulo positivo denota uma rotação no sentido horário, um ângulo
   negativo no sentido anti-horário.
   Em um contexto da direita para a esquerda, um ângulo positivo denota uma rotação no sentido anti-horário, um
   ângulo negativo denota uma rotação no sentido horário.

func (*TagH4) RotateDelta 

func (e *TagH4) RotateDelta(delta float64) (ref *TagH4)

RotateDelta

English: 

Used in conjunction with the Rotate() function, sets the rotation adjustment angle, ie Rotate() = angle + delta.

 Input:
   angle: delta, object rotation adjustment angle.

Português: 

Usada em conjunto com a função Rotate(), define o ângulo de ajuste da rotação, ou seja, Rotate() = angle + delta.

 Entrada:
   angle: delta, ângulo de ajuste da rotação do objeto.

func (*TagH4) SetDeltaX 

func (e *TagH4) SetDeltaX(delta int) (ref *TagH4)

SetDeltaX

English: 

Additional value added in the SetX() function: (x = x + deltaMovieX) and subtracted in the
GetX() function: (x = x - deltaMovieX).

Português: 

Valor adicional adicionado na função SetX(): (x = x + deltaMovieX)  e subtraído na função
GetX(): (x = x - deltaMovieX).

func (*TagH4) SetDeltaY 

func (e *TagH4) SetDeltaY(delta int) (ref *TagH4)

SetDeltaY

English: 

Additional value added in the SetY() function: (y = y + deltaMovieY) and subtracted in the
GetY() function: (y = y - deltaMovieY).

Português: 

Valor adicional adicionado na função SetY(): (y = y + deltaMovieY)  e subtraído na função
GetX(): (y = y - deltaMovieY).

func (*TagH4) SetX 

func (e *TagH4) SetX(x int) (ref *TagH4)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagH4) SetXY 

func (e *TagH4) SetXY(x, y int) (ref *TagH4)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagH4) SetY 

func (e *TagH4) SetY(y int) (ref *TagH4)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagH4) Slot 

func (e *TagH4) Slot(slot string) (ref *TagH4)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagH4) Spellcheck 

func (e *TagH4) Spellcheck(spell bool) (ref *TagH4)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagH4) Style 

func (e *TagH4) Style(style string) (ref *TagH4)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagH4) TabIndex 

func (e *TagH4) TabIndex(index int) (ref *TagH4)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagH4) Text 

func (e *TagH4) Text(value string) (ref *TagH4)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagH4) Title 

func (e *TagH4) Title(title string) (ref *TagH4)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagH4) Translate 

func (e *TagH4) Translate(translate Translate) (ref *TagH4)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

type TagH5 

type TagH5 struct {
	// contains filtered or unexported fields
}

TagH5

English:

The <h1> to <h6> HTML elements represent six levels of section headings. <h1> is the highest section level and <h6> is the lowest.

Multiple <h1> elements on one page

Using more than one <h1> is allowed by the HTML specification, but is not considered a best practice. Using only one <h1> is beneficial for screenreader users.

The HTML specification includes the concept of an outline formed by the use of <section> elements. If this were implemented it would enable the use of multiple <h1> elements, giving user agents—including screen readers—a way to understand that an <h1> nested inside a defined section is a subheading. This functionality has never been implemented; therefore it is important to use your headings to describe the outline of your document. 

Notes:
  * Heading information can be used by user agents to construct a table of contents for a
    document automatically.
  * Avoid using heading elements to resize text. Instead, use the CSS font-size property.
  * Avoid skipping heading levels: always start from <h1>, followed by <h2> and so on.
  * Use only one <h1> per page or view. It should concisely describe the overall purpose of the
    content.
  * The align attribute is obsolete; don't use it.

Português:

Os elementos HTML <h1> a <h6> representam seis níveis de cabeçalho, onde, <h1> é o nível mais alto e <h6> o nível mais baixo.

Múltiplos elementos <h1> em uma página

O uso de mais de um <h1> é permitido pela especificação HTML, mas não é considerado uma prática recomendada. Usar apenas um <h1> é benéfico para usuários de leitores de tela.

A especificação HTML inclui o conceito de contorno formado pelo uso de elementos <section>. Se isso fosse implementado, permitiria o uso de vários elementos <h1>, dando aos agentes do usuário – incluindo leitores de tela – uma maneira de entender que um <h1> aninhado dentro de uma seção definida é um subtítulo. Essa funcionalidade nunca foi implementada; portanto, é importante usar seus títulos para descrever o esboço do seu documento. 

Notas:
  * As informações de cabeçalho podem ser usadas por agentes de usuário para construir
    automaticamente um índice para um documento.
  * Evite usar elementos de título para redimensionar o texto. Em vez disso, use a propriedade
    CSS font-size.
  * Evite pular níveis de título: sempre comece de <h1>, seguido de <h2> e assim por diante.
  * Use apenas um <h1> por página ou visualização. Deve descrever de forma concisa o propósito
    geral do conteúdo.
  * O atributo align está obsoleto; não o use.

func (*TagH5) AccessKey 

func (e *TagH5) AccessKey(key string) (ref *TagH5)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagH5) AddListener 

func (e *TagH5) AddListener(eventType interface{}, manager mouse.SimpleManager) (ref *TagH5)

AddListener

English: 

Associates a function with an event.

 Example:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

Português: 

Associa uma função a um evento.

 Exemplo:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

func (*TagH5) AddPointsToEasingTween 

func (e *TagH5) AddPointsToEasingTween(algorithmRef algorithm.CurveInterface) (ref *TagH5)

AddPointsToEasingTween

English: 

This function returns an easing tween function compatible with the easing onStepFunc() function in order to use the
points generated by the line algorithms as a reference to the movement.

 Note:
   * The 'onStartValue' and 'onEndValue' parameters must have the values 0 and 10000.
     Example:
       factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

Português: 

Esta função retorna uma função easing tween compatível com a função onStepFunc() do easing de modo a usar os pontos
gerados pelos algoritmos de linha como referência ao movimento.

 Nota:
   * O parâmetros 'onStartValue' e 'onEndValue' devem, obrigatoriamente, ter os valores 0 e 10000.
     Exemplo:
       factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

func (*TagH5) Append 

func (e *TagH5) Append(elements ...Compatible) (ref *TagH5)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

fixme: fazer append() assim em todas as tags html, exceto svg

func (*TagH5) AppendById 

func (e *TagH5) AppendById(appendId string) (ref *TagH5)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagH5) AppendToStage 

func (e *TagH5) AppendToStage() (ref *TagH5)

AppendToStage

English: 

Adds a node to the end of the list of children in the main document body. If the node already
exists somewhere in the document, it is removed from its current parent node before being added
to the main document.

Português: 

Adiciona um nó ao final da lista de filhos do corpo do documento principal. Se o nó já existir
em alguma parte do documento, ele é removido de seu nó pai atual antes de ser adicionado ao
documento principal.

todo:https://developer.mozilla.org/en-US/docs/Web/API/Document/createDocumentFragment todo: appendMany()

func (*TagH5) Autofocus 

func (e *TagH5) Autofocus(autofocus bool) (ref *TagH5)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagH5) Class 

func (e *TagH5) Class(class ...string) (ref *TagH5)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagH5) ContentEditable 

func (e *TagH5) ContentEditable(editable bool) (ref *TagH5)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagH5) CreateElement 

func (e *TagH5) CreateElement() (ref *TagH5)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagH5) Data 

func (e *TagH5) Data(data map[string]string) (ref *TagH5)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagH5) Dir 

func (e *TagH5) Dir(dir Dir) (ref *TagH5)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagH5) DragStart 

func (e *TagH5) DragStart() (ref *TagH5)

DragStart

English: 

Mouse drag function.

 Example:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

Português: 

Função de arrastar com o mouse.

 Exemplo:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

func (*TagH5) DragStop 

func (e *TagH5) DragStop() (ref *TagH5)

DragStop

English: 

Stop mouse drag functionality.

 Example:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

   go func() {
     time.Sleep(10 * time.Second)
     div.DragStop()
   }()

Português: 

Para a funcionalidade de arrastar com o mouse.

 Exemplo:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

   go func() {
     time.Sleep(10 * time.Second)
     div.DragStop()
   }()

func (*TagH5) Draggable 

func (e *TagH5) Draggable(draggable Draggable) (ref *TagH5)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagH5) EasingTweenWalkingAndRotateIntoPoints 

func (e *TagH5) EasingTweenWalkingAndRotateIntoPoints() (function func(forTenThousand, percent float64, args interface{}))

EasingTweenWalkingAndRotateIntoPoints

English: 

Moves the element on the line added by the AddPointsToEasingTween() function and adjusts the rotation of the
element with respect to the next point.

This function returns a second function compatible with the easing tween's onStepFunc() function. 

Note:
  * Use the RotateDelta() function to adjust the starting angle;
  * The 'onStartValue' and 'onEndValue' parameters must have the values 0 and 10000.
    Example:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

Português: 

Desloca o elemento na linha adicionada pela função AddPointsToEasingTween() e ajusta a rotação do elemento em relação ao próximo ponto.

Esta função retorna uma segunda função compatível com a função onStepFunc() do easing tween. 

Nota:
  * Use a função RotateDelta() para ajustar o ângulo inicial;
  * O parâmetros 'onStartValue' e 'onEndValue' devem, obrigatoriamente, ter os valores 0 e 10000.
    Exemplo:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

func (*TagH5) EasingTweenWalkingIntoPoints 

func (e *TagH5) EasingTweenWalkingIntoPoints() (function func(percent, p float64, args interface{}))

EasingTweenWalkingIntoPoints

English: 

Moves the element on the line added by the AddPointsToEasingTween() function.

This function returns a second function compatible with the easing tween's onStepFunc() function. 

Note:
  * The 'onStartValue' and 'onEndValue' parameters must have the values 0 and 10000.
    Example:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

Português: 

Desloca o elemento na linha adicionada pela função AddPointsToEasingTween().

Esta função retorna uma segunda função compatível com a função onStepFunc() do easing tween. 

Nota:
  * O parâmetros 'onStartValue' e 'onEndValue' devem, obrigatoriamente, ter os valores 0 e 10000.
    Exemplo:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

func (*TagH5) EnterKeyHint 

func (e *TagH5) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagH5)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagH5) Get 

func (e *TagH5) Get() (el js.Value)

func (*TagH5) GetBottom 

func (e *TagH5) GetBottom() (bottom int)

GetBottom

English: 

It is the same as y + height.

Português: 

É o mesmo que y + Height.

func (*TagH5) GetLeft 

func (e *TagH5) GetLeft() (left int)

GetLeft

English: 

Same as GetY() function, returns the y position of the element.

Português: 

O mesmo que a função GetY(), retorna a posição y do elemento.

func (*TagH5) GetRight 

func (e *TagH5) GetRight() (right int)

GetRight

English: 

It is the same as x + width.

Português: 

É o mesmo que x + width.

func (*TagH5) GetRotateDelta 

func (e *TagH5) GetRotateDelta() (delta float64)

GetRotateDelta

English: 

Returns the rotation adjustment angle, i.e. Rotate() = angle + delta.

 Output:
   angle: delta, object rotation adjustment angle.

Português: 

Retorna o ângulo de ajuste da rotação, ou seja, Rotate() = angle + delta.

 Saída:
   angle: delta, ângulo de ajuste da rotação do objeto.

func (*TagH5) GetTop 

func (e *TagH5) GetTop() (top int)

GetTop

English: 

Same as GetX() function, returns the x position of the element.

Português: 

O mesmo que a função GetX(), retorna a posição x do elemento.

func (*TagH5) GetX 

func (e *TagH5) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagH5) GetXY 

func (e *TagH5) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagH5) GetY 

func (e *TagH5) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagH5) Hidden 

func (e *TagH5) Hidden() (ref *TagH5)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagH5) Html 

func (e *TagH5) Html(value string) (ref *TagH5)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagH5) Id 

func (e *TagH5) Id(id string) (ref *TagH5)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagH5) Init 

func (e *TagH5) Init() (ref *TagH5)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagH5) InputMode 

func (e *TagH5) InputMode(inputMode InputMode) (ref *TagH5)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagH5) Is 

func (e *TagH5) Is(is string) (ref *TagH5)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagH5) ItemDrop 

func (e *TagH5) ItemDrop(itemprop string) (ref *TagH5)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagH5) ItemId 

func (e *TagH5) ItemId(id string) (ref *TagH5)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagH5) ItemRef 

func (e *TagH5) ItemRef(itemref string) (ref *TagH5)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagH5) ItemType 

func (e *TagH5) ItemType(itemType string) (ref *TagH5)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagH5) Lang 

func (e *TagH5) Lang(language Language) (ref *TagH5)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagH5) Mouse 

func (e *TagH5) Mouse(value mouse.CursorType) (ref *TagH5)

Mouse

English: 

Defines the shape of the mouse pointer.

 Input:
   value: mouse pointer shape.
     Example: SetMouse(mouse.KCursorCell) // Use mouse.K... and let autocomplete do the
              rest

Português: 

Define o formato do ponteiro do mouse.

 Entrada:
   value: formato do ponteiro do mouse.
     Exemplo: SetMouse(mouse.KCursorCell) // Use mouse.K... e deixe o autocompletar fazer
              o resto

func (*TagH5) Nonce 

func (e *TagH5) Nonce(part ...string) (ref *TagH5)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagH5) RemoveListener 

func (e *TagH5) RemoveListener(eventType interface{}) (ref *TagH5)

RemoveListener

English: 

Remove the function associated with the event

 Example:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

Português: 

Remove a função associada com o evento.

 Exemplo:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

func (*TagH5) Rotate 

func (e *TagH5) Rotate(angle float64) (ref *TagH5)

Rotate

English: 

Defines a transformation that rotates an element around a fixed point on the 2D plane, without deforming it.

 Input:
   angle: representing the angle of the rotation. The direction of rotation depends on the writing direction.
   In a left-to-right context, a positive angle denotes a clockwise rotation, a negative angle a counter-clockwise
   one.
   In a right-to-left context, a positive angle denotes a counter-clockwise rotation, a negative angle a clockwise
   one.

Português: 

Define uma transformação que gira um elemento em torno de um ponto fixo no plano 2D, sem deformá-lo.

 Entrada:
   angle: representando o ângulo de rotação. O sentido de rotação depende do sentido de escrita.
   Em um contexto da esquerda para a direita, um ângulo positivo denota uma rotação no sentido horário, um ângulo
   negativo no sentido anti-horário.
   Em um contexto da direita para a esquerda, um ângulo positivo denota uma rotação no sentido anti-horário, um
   ângulo negativo denota uma rotação no sentido horário.

func (*TagH5) RotateDelta 

func (e *TagH5) RotateDelta(delta float64) (ref *TagH5)

RotateDelta

English: 

Used in conjunction with the Rotate() function, sets the rotation adjustment angle, ie Rotate() = angle + delta.

 Input:
   angle: delta, object rotation adjustment angle.

Português: 

Usada em conjunto com a função Rotate(), define o ângulo de ajuste da rotação, ou seja, Rotate() = angle + delta.

 Entrada:
   angle: delta, ângulo de ajuste da rotação do objeto.

func (*TagH5) SetDeltaX 

func (e *TagH5) SetDeltaX(delta int) (ref *TagH5)

SetDeltaX

English: 

Additional value added in the SetX() function: (x = x + deltaMovieX) and subtracted in the
GetX() function: (x = x - deltaMovieX).

Português: 

Valor adicional adicionado na função SetX(): (x = x + deltaMovieX)  e subtraído na função
GetX(): (x = x - deltaMovieX).

func (*TagH5) SetDeltaY 

func (e *TagH5) SetDeltaY(delta int) (ref *TagH5)

SetDeltaY

English: 

Additional value added in the SetY() function: (y = y + deltaMovieY) and subtracted in the
GetY() function: (y = y - deltaMovieY).

Português: 

Valor adicional adicionado na função SetY(): (y = y + deltaMovieY)  e subtraído na função
GetX(): (y = y - deltaMovieY).

func (*TagH5) SetX 

func (e *TagH5) SetX(x int) (ref *TagH5)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagH5) SetXY 

func (e *TagH5) SetXY(x, y int) (ref *TagH5)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagH5) SetY 

func (e *TagH5) SetY(y int) (ref *TagH5)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagH5) Slot 

func (e *TagH5) Slot(slot string) (ref *TagH5)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagH5) Spellcheck 

func (e *TagH5) Spellcheck(spell bool) (ref *TagH5)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagH5) Style 

func (e *TagH5) Style(style string) (ref *TagH5)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagH5) TabIndex 

func (e *TagH5) TabIndex(index int) (ref *TagH5)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagH5) Text 

func (e *TagH5) Text(value string) (ref *TagH5)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagH5) Title 

func (e *TagH5) Title(title string) (ref *TagH5)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagH5) Translate 

func (e *TagH5) Translate(translate Translate) (ref *TagH5)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

type TagH6 

type TagH6 struct {
	// contains filtered or unexported fields
}

TagH6

English:

The <h1> to <h6> HTML elements represent six levels of section headings. <h1> is the highest section level and <h6> is the lowest.

Multiple <h1> elements on one page

Using more than one <h1> is allowed by the HTML specification, but is not considered a best practice. Using only one <h1> is beneficial for screenreader users.

The HTML specification includes the concept of an outline formed by the use of <section> elements. If this were implemented it would enable the use of multiple <h1> elements, giving user agents—including screen readers—a way to understand that an <h1> nested inside a defined section is a subheading. This functionality has never been implemented; therefore it is important to use your headings to describe the outline of your document. 

Notes:
  * Heading information can be used by user agents to construct a table of contents for a
    document automatically.
  * Avoid using heading elements to resize text. Instead, use the CSS font-size property.
  * Avoid skipping heading levels: always start from <h1>, followed by <h2> and so on.
  * Use only one <h1> per page or view. It should concisely describe the overall purpose of the
    content.
  * The align attribute is obsolete; don't use it.

Português:

Os elementos HTML <h1> a <h6> representam seis níveis de cabeçalho, onde, <h1> é o nível mais alto e <h6> o nível mais baixo.

Múltiplos elementos <h1> em uma página

O uso de mais de um <h1> é permitido pela especificação HTML, mas não é considerado uma prática recomendada. Usar apenas um <h1> é benéfico para usuários de leitores de tela.

A especificação HTML inclui o conceito de contorno formado pelo uso de elementos <section>. Se isso fosse implementado, permitiria o uso de vários elementos <h1>, dando aos agentes do usuário – incluindo leitores de tela – uma maneira de entender que um <h1> aninhado dentro de uma seção definida é um subtítulo. Essa funcionalidade nunca foi implementada; portanto, é importante usar seus títulos para descrever o esboço do seu documento. 

Notas:
  * As informações de cabeçalho podem ser usadas por agentes de usuário para construir
    automaticamente um índice para um documento.
  * Evite usar elementos de título para redimensionar o texto. Em vez disso, use a propriedade
    CSS font-size.
  * Evite pular níveis de título: sempre comece de <h1>, seguido de <h2> e assim por diante.
  * Use apenas um <h1> por página ou visualização. Deve descrever de forma concisa o propósito
    geral do conteúdo.
  * O atributo align está obsoleto; não o use.

func (*TagH6) AccessKey 

func (e *TagH6) AccessKey(key string) (ref *TagH6)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagH6) AddListener 

func (e *TagH6) AddListener(eventType interface{}, manager mouse.SimpleManager) (ref *TagH6)

AddListener

English: 

Associates a function with an event.

 Example:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

Português: 

Associa uma função a um evento.

 Exemplo:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

func (*TagH6) AddPointsToEasingTween 

func (e *TagH6) AddPointsToEasingTween(algorithmRef algorithm.CurveInterface) (ref *TagH6)

AddPointsToEasingTween

English: 

This function returns an easing tween function compatible with the easing onStepFunc() function in order to use the
points generated by the line algorithms as a reference to the movement.

 Note:
   * The 'onStartValue' and 'onEndValue' parameters must have the values 0 and 10000.
     Example:
       factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

Português: 

Esta função retorna uma função easing tween compatível com a função onStepFunc() do easing de modo a usar os pontos
gerados pelos algoritmos de linha como referência ao movimento.

 Nota:
   * O parâmetros 'onStartValue' e 'onEndValue' devem, obrigatoriamente, ter os valores 0 e 10000.
     Exemplo:
       factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

func (*TagH6) Append 

func (e *TagH6) Append(elements ...Compatible) (ref *TagH6)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

fixme: fazer append() assim em todas as tags html, exceto svg

func (*TagH6) AppendById 

func (e *TagH6) AppendById(appendId string) (ref *TagH6)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagH6) AppendToStage 

func (e *TagH6) AppendToStage() (ref *TagH6)

AppendToStage

English: 

Adds a node to the end of the list of children in the main document body. If the node already
exists somewhere in the document, it is removed from its current parent node before being added
to the main document.

Português: 

Adiciona um nó ao final da lista de filhos do corpo do documento principal. Se o nó já existir
em alguma parte do documento, ele é removido de seu nó pai atual antes de ser adicionado ao
documento principal.

todo:https://developer.mozilla.org/en-US/docs/Web/API/Document/createDocumentFragment todo: appendMany()

func (*TagH6) Autofocus 

func (e *TagH6) Autofocus(autofocus bool) (ref *TagH6)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagH6) Class 

func (e *TagH6) Class(class ...string) (ref *TagH6)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagH6) ContentEditable 

func (e *TagH6) ContentEditable(editable bool) (ref *TagH6)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagH6) CreateElement 

func (e *TagH6) CreateElement() (ref *TagH6)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagH6) Data 

func (e *TagH6) Data(data map[string]string) (ref *TagH6)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagH6) Dir 

func (e *TagH6) Dir(dir Dir) (ref *TagH6)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagH6) DragStart 

func (e *TagH6) DragStart() (ref *TagH6)

DragStart

English: 

Mouse drag function.

 Example:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

Português: 

Função de arrastar com o mouse.

 Exemplo:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

func (*TagH6) DragStop 

func (e *TagH6) DragStop() (ref *TagH6)

DragStop

English: 

Stop mouse drag functionality.

 Example:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

   go func() {
     time.Sleep(10 * time.Second)
     div.DragStop()
   }()

Português: 

Para a funcionalidade de arrastar com o mouse.

 Exemplo:

   factoryBrowser.NewTagDiv("div_0").
     Class("animate").
     DragStart().
     AppendById("stage")

   go func() {
     time.Sleep(10 * time.Second)
     div.DragStop()
   }()

func (*TagH6) Draggable 

func (e *TagH6) Draggable(draggable Draggable) (ref *TagH6)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagH6) EasingTweenWalkingAndRotateIntoPoints 

func (e *TagH6) EasingTweenWalkingAndRotateIntoPoints() (function func(forTenThousand, percent float64, args interface{}))

EasingTweenWalkingAndRotateIntoPoints

English: 

Moves the element on the line added by the AddPointsToEasingTween() function and adjusts the rotation of the
element with respect to the next point.

This function returns a second function compatible with the easing tween's onStepFunc() function. 

Note:
  * Use the RotateDelta() function to adjust the starting angle;
  * The 'onStartValue' and 'onEndValue' parameters must have the values 0 and 10000.
    Example:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

Português: 

Desloca o elemento na linha adicionada pela função AddPointsToEasingTween() e ajusta a rotação do elemento em relação ao próximo ponto.

Esta função retorna uma segunda função compatível com a função onStepFunc() do easing tween. 

Nota:
  * Use a função RotateDelta() para ajustar o ângulo inicial;
  * O parâmetros 'onStartValue' e 'onEndValue' devem, obrigatoriamente, ter os valores 0 e 10000.
    Exemplo:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

func (*TagH6) EasingTweenWalkingIntoPoints 

func (e *TagH6) EasingTweenWalkingIntoPoints() (function func(percent, p float64, args interface{}))

EasingTweenWalkingIntoPoints

English: 

Moves the element on the line added by the AddPointsToEasingTween() function.

This function returns a second function compatible with the easing tween's onStepFunc() function. 

Note:
  * The 'onStartValue' and 'onEndValue' parameters must have the values 0 and 10000.
    Example:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

Português: 

Desloca o elemento na linha adicionada pela função AddPointsToEasingTween().

Esta função retorna uma segunda função compatível com a função onStepFunc() do easing tween. 

Nota:
  * O parâmetros 'onStartValue' e 'onEndValue' devem, obrigatoriamente, ter os valores 0 e 10000.
    Exemplo:
      factoryEasingTween.NewLinear(5*time.Second, 0, 10000, div.EasingTweenWalkingAndRotateIntoPoints(), 0)

func (*TagH6) EnterKeyHint 

func (e *TagH6) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagH6)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagH6) Get 

func (e *TagH6) Get() (el js.Value)

func (*TagH6) GetBottom 

func (e *TagH6) GetBottom() (bottom int)

GetBottom

English: 

It is the same as y + height.

Português: 

É o mesmo que y + Height.

func (*TagH6) GetLeft 

func (e *TagH6) GetLeft() (left int)

GetLeft

English: 

Same as GetY() function, returns the y position of the element.

Português: 

O mesmo que a função GetY(), retorna a posição y do elemento.

func (*TagH6) GetRight 

func (e *TagH6) GetRight() (right int)

GetRight

English: 

It is the same as x + width.

Português: 

É o mesmo que x + width.

func (*TagH6) GetRotateDelta 

func (e *TagH6) GetRotateDelta() (delta float64)

GetRotateDelta

English: 

Returns the rotation adjustment angle, i.e. Rotate() = angle + delta.

 Output:
   angle: delta, object rotation adjustment angle.

Português: 

Retorna o ângulo de ajuste da rotação, ou seja, Rotate() = angle + delta.

 Saída:
   angle: delta, ângulo de ajuste da rotação do objeto.

func (*TagH6) GetTop 

func (e *TagH6) GetTop() (top int)

GetTop

English: 

Same as GetX() function, returns the x position of the element.

Português: 

O mesmo que a função GetX(), retorna a posição x do elemento.

func (*TagH6) GetX 

func (e *TagH6) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagH6) GetXY 

func (e *TagH6) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagH6) GetY 

func (e *TagH6) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagH6) Hidden 

func (e *TagH6) Hidden() (ref *TagH6)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagH6) Html 

func (e *TagH6) Html(value string) (ref *TagH6)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagH6) Id 

func (e *TagH6) Id(id string) (ref *TagH6)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagH6) Init 

func (e *TagH6) Init() (ref *TagH6)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagH6) InputMode 

func (e *TagH6) InputMode(inputMode InputMode) (ref *TagH6)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagH6) Is 

func (e *TagH6) Is(is string) (ref *TagH6)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagH6) ItemDrop 

func (e *TagH6) ItemDrop(itemprop string) (ref *TagH6)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagH6) ItemId 

func (e *TagH6) ItemId(id string) (ref *TagH6)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagH6) ItemRef 

func (e *TagH6) ItemRef(itemref string) (ref *TagH6)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagH6) ItemType 

func (e *TagH6) ItemType(itemType string) (ref *TagH6)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagH6) Lang 

func (e *TagH6) Lang(language Language) (ref *TagH6)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagH6) Mouse 

func (e *TagH6) Mouse(value mouse.CursorType) (ref *TagH6)

Mouse

English: 

Defines the shape of the mouse pointer.

 Input:
   value: mouse pointer shape.
     Example: SetMouse(mouse.KCursorCell) // Use mouse.K... and let autocomplete do the
              rest

Português: 

Define o formato do ponteiro do mouse.

 Entrada:
   value: formato do ponteiro do mouse.
     Exemplo: SetMouse(mouse.KCursorCell) // Use mouse.K... e deixe o autocompletar fazer
              o resto

func (*TagH6) Nonce 

func (e *TagH6) Nonce(part ...string) (ref *TagH6)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagH6) RemoveListener 

func (e *TagH6) RemoveListener(eventType interface{}) (ref *TagH6)

RemoveListener

English: 

Remove the function associated with the event

 Example:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

Português: 

Remove a função associada com o evento.

 Exemplo:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

func (*TagH6) Rotate 

func (e *TagH6) Rotate(angle float64) (ref *TagH6)

Rotate

English: 

Defines a transformation that rotates an element around a fixed point on the 2D plane, without deforming it.

 Input:
   angle: representing the angle of the rotation. The direction of rotation depends on the writing direction.
   In a left-to-right context, a positive angle denotes a clockwise rotation, a negative angle a counter-clockwise
   one.
   In a right-to-left context, a positive angle denotes a counter-clockwise rotation, a negative angle a clockwise
   one.

Português: 

Define uma transformação que gira um elemento em torno de um ponto fixo no plano 2D, sem deformá-lo.

 Entrada:
   angle: representando o ângulo de rotação. O sentido de rotação depende do sentido de escrita.
   Em um contexto da esquerda para a direita, um ângulo positivo denota uma rotação no sentido horário, um ângulo
   negativo no sentido anti-horário.
   Em um contexto da direita para a esquerda, um ângulo positivo denota uma rotação no sentido anti-horário, um
   ângulo negativo denota uma rotação no sentido horário.

func (*TagH6) RotateDelta 

func (e *TagH6) RotateDelta(delta float64) (ref *TagH6)

RotateDelta

English: 

Used in conjunction with the Rotate() function, sets the rotation adjustment angle, ie Rotate() = angle + delta.

 Input:
   angle: delta, object rotation adjustment angle.

Português: 

Usada em conjunto com a função Rotate(), define o ângulo de ajuste da rotação, ou seja, Rotate() = angle + delta.

 Entrada:
   angle: delta, ângulo de ajuste da rotação do objeto.

func (*TagH6) SetDeltaX 

func (e *TagH6) SetDeltaX(delta int) (ref *TagH6)

SetDeltaX

English: 

Additional value added in the SetX() function: (x = x + deltaMovieX) and subtracted in the
GetX() function: (x = x - deltaMovieX).

Português: 

Valor adicional adicionado na função SetX(): (x = x + deltaMovieX)  e subtraído na função
GetX(): (x = x - deltaMovieX).

func (*TagH6) SetDeltaY 

func (e *TagH6) SetDeltaY(delta int) (ref *TagH6)

SetDeltaY

English: 

Additional value added in the SetY() function: (y = y + deltaMovieY) and subtracted in the
GetY() function: (y = y - deltaMovieY).

Português: 

Valor adicional adicionado na função SetY(): (y = y + deltaMovieY)  e subtraído na função
GetX(): (y = y - deltaMovieY).

func (*TagH6) SetX 

func (e *TagH6) SetX(x int) (ref *TagH6)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagH6) SetXY 

func (e *TagH6) SetXY(x, y int) (ref *TagH6)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagH6) SetY 

func (e *TagH6) SetY(y int) (ref *TagH6)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagH6) Slot 

func (e *TagH6) Slot(slot string) (ref *TagH6)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagH6) Spellcheck 

func (e *TagH6) Spellcheck(spell bool) (ref *TagH6)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagH6) Style 

func (e *TagH6) Style(style string) (ref *TagH6)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagH6) TabIndex 

func (e *TagH6) TabIndex(index int) (ref *TagH6)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagH6) Text 

func (e *TagH6) Text(value string) (ref *TagH6)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagH6) Title 

func (e *TagH6) Title(title string) (ref *TagH6)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagH6) Translate 

func (e *TagH6) Translate(translate Translate) (ref *TagH6)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

type TagImg 

type TagImg struct {
	// contains filtered or unexported fields
}

func (*TagImg) AccessKey 

func (e *TagImg) AccessKey(key string) (ref *TagImg)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagImg) Alt 

func (e *TagImg) Alt(alt string) (ref *TagImg)

Alt

English: 

The alt attribute provides alternative text for the image, displaying the value of the attribute
if the image src is missing or otherwise fails to load.

Português: 

O atributo alt fornece texto alternativo para a imagem, exibindo o valor do atributo se o src da
imagem estiver ausente ou falhar ao carregar.

func (*TagImg) Append 

func (e *TagImg) Append(append interface{}) (ref *TagImg)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagImg) AppendById 

func (e *TagImg) AppendById(appendId string) (ref *TagImg)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagImg) Autofocus 

func (e *TagImg) Autofocus(autofocus bool) (ref *TagImg)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagImg) Class 

func (e *TagImg) Class(class ...string) (ref *TagImg)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagImg) ContentEditable 

func (e *TagImg) ContentEditable(editable bool) (ref *TagImg)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagImg) CreateElement 

func (e *TagImg) CreateElement() (ref *TagImg)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagImg) CrossOrigin 

func (e *TagImg) CrossOrigin(cross CrossOrigin) (ref *TagImg)

CrossOrigin

English: 

Indicates if the fetching of the image must be done using a CORS request.

Image data from a CORS-enabled image returned from a CORS request can be reused in the <canvas> element without being marked "tainted".

If the crossorigin attribute is not specified, then a non-CORS request is sent (without the Origin request header), and the browser marks the image as tainted and restricts access to its image data, preventing its usage in <canvas> elements.

If the crossorigin attribute is specified, then a CORS request is sent (with the Origin request header); but if the server does not opt into allowing cross-origin access to the image data by the origin site (by not sending any Access-Control-Allow-Origin response header, or by not including the site's origin in any Access-Control-Allow-Origin response header it does send), then the browser blocks the image from loading, and logs a CORS error to the devtools console.

Português: 

Indica se a busca da imagem deve ser feita por meio de uma solicitação CORS.

Os dados de imagem de uma imagem habilitada para CORS retornados de uma solicitação CORS podem ser reutilizados no elemento <canvas> sem serem marcados como "contaminados".

Se o atributo crossorigin não for especificado, uma solicitação não CORS é enviada (sem o cabeçalho da solicitação Origin) e o navegador marca a imagem como contaminada e restringe o acesso aos dados da imagem, impedindo seu uso em elementos <canvas>.

Se o atributo crossorigin for especificado, uma solicitação CORS será enviada (com o cabeçalho da solicitação Origem); mas se o servidor não permitir o acesso de origem cruzada aos dados da imagem pelo site de origem (não enviando nenhum cabeçalho de resposta Access-Control-Allow-Origin ou não incluindo a origem do site em qualquer Access-Control-Allow-Origin response header que ele envia), o navegador bloqueia o carregamento da imagem e registra um erro CORS no console devtools.

func (*TagImg) Data 

func (e *TagImg) Data(data map[string]string) (ref *TagImg)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagImg) Decoding 

func (e *TagImg) Decoding(decoding Decoding) (ref *TagImg)

Decoding

English: 

Provides an image decoding hint to the browser.

Português: 

Fornece uma dica de decodificação de imagem para o navegador.

func (*TagImg) Dir 

func (e *TagImg) Dir(dir Dir) (ref *TagImg)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagImg) Draggable 

func (e *TagImg) Draggable(draggable Draggable) (ref *TagImg)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagImg) EnterKeyHint 

func (e *TagImg) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagImg)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagImg) FetchPriority 

func (e *TagImg) FetchPriority(priority FetchPriority) (ref *TagImg)

FetchPriority

English: 

Provides a hint of the relative priority to use when fetching the image.

Português: 

Fornece uma dica da prioridade relativa a ser usada ao buscar a imagem.

func (*TagImg) Get 

func (e *TagImg) Get() (el js.Value)

func (*TagImg) GetX 

func (e *TagImg) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagImg) GetXY 

func (e *TagImg) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagImg) GetY 

func (e *TagImg) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagImg) Hidden 

func (e *TagImg) Hidden() (ref *TagImg)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagImg) Id 

func (e *TagImg) Id(id string) (ref *TagImg)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagImg) Init 

func (e *TagImg) Init() (ref *TagImg)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagImg) InputMode 

func (e *TagImg) InputMode(inputMode InputMode) (ref *TagImg)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagImg) Is 

func (e *TagImg) Is(is string) (ref *TagImg)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagImg) IsMap 

func (e *TagImg) IsMap(isMap bool) (ref *TagImg)

IsMap

English: 

This Boolean attribute indicates that the image is part of a server-side map. If so, the
coordinates where the user clicked on the image are sent to the server.

 Note:
   * This attribute is allowed only if the <img> element is a descendant of an <a> element with a
     valid href attribute. This gives users without pointing devices a fallback destination.

Português: 

Este atributo booleano indica que a imagem faz parte de um mapa do lado do servidor.
Se sim, as coordenadas onde o usuário clicou na imagem são enviadas para o servidor.

 Nota:
   * Este atributo é permitido somente se o elemento <img> for descendente de um elemento <a> com
     um atributo href válido. Isso oferece aos usuários sem dispositivos apontadores um destino
     de fallback.

func (*TagImg) ItemDrop 

func (e *TagImg) ItemDrop(itemprop string) (ref *TagImg)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagImg) ItemId 

func (e *TagImg) ItemId(id string) (ref *TagImg)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagImg) ItemRef 

func (e *TagImg) ItemRef(itemref string) (ref *TagImg)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagImg) ItemType 

func (e *TagImg) ItemType(itemType string) (ref *TagImg)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagImg) Lang 

func (e *TagImg) Lang(language Language) (ref *TagImg)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagImg) Nonce 

func (e *TagImg) Nonce(part ...string) (ref *TagImg)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagImg) ReferrerPolicy 

func (e *TagImg) ReferrerPolicy(referrerPolicy ReferrerPolicy) (ref *TagImg)

ReferrerPolicy

English: 

How much of the referrer to send when following the link.

 KRefPolicyNoReferrer: The Referer header will not be sent.
 KRefPolicyNoReferrerWhenDowngrade: The Referer header will not be sent to origins without TLS
   (HTTPS).
 KRefPolicyOrigin: The sent referrer will be limited to the origin of the referring page: its
   scheme, host, and port.
 KRefPolicyOriginWhenCrossOrigin: The referrer sent to other origins will be limited to the
   scheme, the host, and the port. Navigations on the same origin will still include the path.
 KRefPolicySameOrigin: A referrer will be sent for same origin, but cross-origin requests will
   contain no referrer information.
 KRefPolicyStrictOrigin: Only send the origin of the document as the referrer when the protocol
   security level stays the same (HTTPS→HTTPS), but don't send it to a less secure destination
   (HTTPS→HTTP).
 KRefPolicyStrictOriginWhenCrossOrigin (default): Send a full URL when performing a same-origin
   request, only send the origin when the protocol security level stays the same (HTTPS→HTTPS),
   and send no header to a less secure destination (HTTPS→HTTP).
 KRefPolicyUnsafeUrl: The referrer will include the origin and the path (but not the fragment,
   password, or username). This value is unsafe, because it leaks origins and paths from
   TLS-protected resources to insecure origins.

 Note:
   * Experimental. Expect behavior to change in the future. (04/2022)

Português: 

Quanto do referenciador enviar ao seguir o link.

 KRefPolicyNoReferrer: O cabeçalho Referer não será enviado.
 KRefPolicyNoReferrerWhenDowngrade: O cabeçalho Referer não será enviado para origens sem TLS
   (HTTPS).
 KRefPolicyOrigin: O referenciador enviado será limitado à origem da página de referência: seu
   esquema, host e porta.
 KRefPolicyOriginWhenCrossOrigin: O referenciador enviado para outras origens será limitado ao
   esquema, ao host e à porta. As navegações na mesma origem ainda incluirão o caminho.
 KRefPolicySameOrigin: Um referenciador será enviado para a mesma origem, mas as solicitações de
   origem cruzada não conterão informações de referenciador.
 KRefPolicyStrictOrigin: Só envie a origem do documento como referenciador quando o nível de
   segurança do protocolo permanecer o mesmo (HTTPS→HTTPS), mas não envie para um destino menos
   seguro (HTTPS→HTTP).
 KRefPolicyStrictOriginWhenCrossOrigin (padrão): Envie uma URL completa ao realizar uma
   solicitação de mesma origem, envie a origem apenas quando o nível de segurança do protocolo
   permanecer o mesmo (HTTPS→HTTPS) e não envie nenhum cabeçalho para um destino menos seguro
   (HTTPS→HTTP).
 KRefPolicyUnsafeUrl: O referenciador incluirá a origem e o caminho (mas não o fragmento, a senha
   ou o nome de usuário). Esse valor não é seguro porque vaza origens e caminhos de recursos
   protegidos por TLS para origens inseguras.

 Note:
   * Experimental. Expect behavior to change in the future. (04/2022)

func (*TagImg) SetDeltaX 

func (e *TagImg) SetDeltaX(delta int) (ref *TagImg)

SetDeltaX

English: 

Additional value added in the SetX() function: (x = x + deltaMovieX) and subtracted in the
GetX() function: (x = x - deltaMovieX).

Português: 

Valor adicional adicionado na função SetX(): (x = x + deltaMovieX)  e subtraído na função
GetX(): (x = x - deltaMovieX).

func (*TagImg) SetDeltaY 

func (e *TagImg) SetDeltaY(delta int) (ref *TagImg)

SetDeltaY

English: 

Additional value added in the SetY() function: (y = y + deltaMovieY) and subtracted in the
GetY() function: (y = y - deltaMovieY).

Português: 

Valor adicional adicionado na função SetY(): (y = y + deltaMovieY)  e subtraído na função
GetX(): (y = y - deltaMovieY).

func (*TagImg) SetX 

func (e *TagImg) SetX(x int) (ref *TagImg)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagImg) SetXY 

func (e *TagImg) SetXY(x, y int) (ref *TagImg)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagImg) SetY 

func (e *TagImg) SetY(y int) (ref *TagImg)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagImg) Sizes 

func (e *TagImg) Sizes(sizes string) (ref *TagImg)

Sizes

English: 

One or more strings separated by commas, indicating a set of source sizes. Each source size
consists of:
  1 A media condition. This must be omitted for the last item in the list.
  2 A source size value.

Media Conditions describe properties of the viewport, not of the image. For example, (max-height: 500px) 1000px proposes to use a source of 1000px width, if the viewport is not higher than 500px.

Source size values specify the intended display size of the image. User agents use the current source size to select one of the sources supplied by the srcset attribute, when those sources are described using width (w) descriptors. The selected source size affects the intrinsic size of the image (the image's display size if no CSS styling is applied). If the srcset attribute is absent, or contains no values with a width descriptor, then the sizes attribute has no effect.

Português: 

Uma ou mais strings separadas por vírgulas, indicando um conjunto de tamanhos de origem. Cada
tamanho de origem consiste em:
  1 Uma condição de mídia. Isso deve ser omitido para o último item da lista.
  2 Um valor de tamanho de origem.

As condições de mídia descrevem as propriedades da janela de visualização, não da imagem. Por exemplo, (max-height: 500px) 1000px propõe usar uma fonte de 1000px de largura, se a janela de visualização não for maior que 500px.

Os valores de tamanho de origem especificam o tamanho de exibição pretendido da imagem. Os agentes do usuário usam o tamanho da fonte atual para selecionar uma das fontes fornecidas pelo atributo srcset, quando essas fontes são descritas usando descritores de largura (w). O tamanho de origem selecionado afeta o tamanho intrínseco da imagem (o tamanho de exibição da imagem se nenhum estilo CSS for aplicado). Se o atributo srcset estiver ausente ou não contiver valores com um descritor de largura, o atributo tamanhos não terá efeito.

func (*TagImg) Slot 

func (e *TagImg) Slot(slot string) (ref *TagImg)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagImg) Spellcheck 

func (e *TagImg) Spellcheck(spell bool) (ref *TagImg)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagImg) Src 

func (e *TagImg) Src(src string, waitLoad bool) (ref *TagImg)

Src

English: 

The image URL. Mandatory for the <img> element. On browsers supporting srcset, src is treated
like a candidate image with a pixel density descriptor 1x, unless an image with this pixel
density descriptor is already defined in srcset, or unless srcset contains w descriptors.

Português: 

O URL da imagem. Obrigatório para o elemento <img>. Em navegadores que suportam srcset, src é
tratado como uma imagem candidata com um descritor de densidade de pixels 1x, a menos que uma
imagem com esse descritor de densidade de pixels já esteja definida em srcset, ou a menos que
srcset contenha descritores w.

func (*TagImg) SrcSet 

func (e *TagImg) SrcSet(srcSet string) (ref *TagImg)

SrcSet

English: 

One or more strings separated by commas, indicating possible image sources for the user agent to
use. Each string is composed of:
  1 A URL to an image
  2 Optionally, whitespace followed by one of:
    * A width descriptor (a positive integer directly followed by w). The width descriptor is
      divided by the source size given in the sizes attribute to calculate the effective pixel
      density.
    * A pixel density descriptor (a positive floating point number directly followed by x).

If no descriptor is specified, the source is assigned the default descriptor of 1x.

It is incorrect to mix width descriptors and pixel density descriptors in the same srcset attribute. Duplicate descriptors (for instance, two sources in the same srcset which are both described with 2x) are also invalid.

The user agent selects any of the available sources at its discretion. This provides them with significant leeway to tailor their selection based on things like user preferences or bandwidth conditions. See our Responsive images tutorial for an example.

Português: 

Uma ou mais strings separadas por vírgulas, indicando possíveis fontes de imagem para o agente do
usuário usar. Cada corda é composta por:
  1 Um URL para uma imagem
  2 Opcionalmente, espaço em branco seguido por um dos seguintes:
    * Um descritor de largura (um inteiro positivo seguido diretamente por w). O descritor de
      largura é dividido pelo tamanho da fonte fornecido no atributo de tamanhos para calcular a
      densidade de pixels efetiva.
    * Um descritor de densidade de pixels (um número de ponto flutuante positivo seguido
      diretamente por x).

Se nenhum descritor for especificado, a origem receberá o descritor padrão de 1x.

É incorreto misturar descritores de largura e descritores de densidade de pixels no mesmo atributo srcset. Descritores duplicados (por exemplo, duas fontes no mesmo srcset que são ambas descritas com 2x) também são inválidas.

O agente do usuário seleciona qualquer uma das fontes disponíveis a seu critério. Isso fornece a eles uma margem de manobra significativa para personalizar sua seleção com base em coisas como preferências do usuário ou condições de largura de banda. Veja nosso tutorial de imagens responsivas para obter um exemplo.

func (*TagImg) Style 

func (e *TagImg) Style(style string) (ref *TagImg)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagImg) TabIndex 

func (e *TagImg) TabIndex(index int) (ref *TagImg)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagImg) Title 

func (e *TagImg) Title(title string) (ref *TagImg)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagImg) Translate 

func (e *TagImg) Translate(translate Translate) (ref *TagImg)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagImg) UseMap 

func (e *TagImg) UseMap(useMap bool) (ref *TagImg)

UseMap

English: 

The partial URL (starting with #) of an image map associated with the element.

 Note:
   * You cannot use this attribute if the <img> element is inside an <a> or <button> element.

Português: 

The partial URL (starting with #) of an image map associated with the element.

 Note:
   * You cannot use this attribute if the <img> element is inside an <a> or <button> element.

func (*TagImg) Width 

func (e *TagImg) Width(width int) (ref *TagImg)

Width

English: 

The intrinsic width of the image in pixels. Must be an integer without a unit.

Português: 

A largura intrínseca da imagem em pixels. Deve ser um número inteiro sem uma unidade.

type TagInputButton 

type TagInputButton struct {
	// contains filtered or unexported fields
}

func (*TagInputButton) AccessKey 

func (e *TagInputButton) AccessKey(key string) (ref *TagInputButton)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputButton) Append 

func (e *TagInputButton) Append(append interface{}) (ref *TagInputButton)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputButton) AppendById 

func (e *TagInputButton) AppendById(appendId string) (ref *TagInputButton)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputButton) Autocomplete 

func (e *TagInputButton) Autocomplete(autocomplete Autocomplete) (ref *TagInputButton)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputButton) Autofocus 

func (e *TagInputButton) Autofocus(autofocus bool) (ref *TagInputButton)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputButton) Class 

func (e *TagInputButton) Class(class ...string) (ref *TagInputButton)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputButton) ContentEditable 

func (e *TagInputButton) ContentEditable(editable bool) (ref *TagInputButton)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputButton) CreateElement 

func (e *TagInputButton) CreateElement(tag Tag) (ref *TagInputButton)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputButton) Data 

func (e *TagInputButton) Data(data map[string]string) (ref *TagInputButton)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputButton) Dir 

func (e *TagInputButton) Dir(dir Dir) (ref *TagInputButton)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputButton) Disabled 

func (e *TagInputButton) Disabled(disabled bool) (ref *TagInputButton)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputButton) Draggable 

func (e *TagInputButton) Draggable(draggable Draggable) (ref *TagInputButton)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputButton) EnterKeyHint 

func (e *TagInputButton) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputButton)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputButton) Form 

func (e *TagInputButton) Form(form string) (ref *TagInputButton)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputButton) GetX 

func (e *TagInputButton) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputButton) GetXY 

func (e *TagInputButton) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputButton) GetY 

func (e *TagInputButton) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputButton) Hidden 

func (e *TagInputButton) Hidden() (ref *TagInputButton)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputButton) Id 

func (e *TagInputButton) Id(id string) (ref *TagInputButton)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputButton) InputMode 

func (e *TagInputButton) InputMode(inputMode InputMode) (ref *TagInputButton)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputButton) Is 

func (e *TagInputButton) Is(is string) (ref *TagInputButton)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputButton) ItemDrop 

func (e *TagInputButton) ItemDrop(itemprop string) (ref *TagInputButton)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputButton) ItemId 

func (e *TagInputButton) ItemId(id string) (ref *TagInputButton)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputButton) ItemRef 

func (e *TagInputButton) ItemRef(itemref string) (ref *TagInputButton)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputButton) ItemType 

func (e *TagInputButton) ItemType(itemType string) (ref *TagInputButton)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputButton) Lang 

func (e *TagInputButton) Lang(language Language) (ref *TagInputButton)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputButton) List 

func (e *TagInputButton) List(list string) (ref *TagInputButton)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputButton) Name 

func (e *TagInputButton) Name(name string) (ref *TagInputButton)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputButton) Nonce 

func (e *TagInputButton) Nonce(part ...string) (ref *TagInputButton)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputButton) ReadOnly 

func (e *TagInputButton) ReadOnly(readonly bool) (ref *TagInputButton)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputButton) Required 

func (e *TagInputButton) Required(required bool) (ref *TagInputButton)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputButton) SetX 

func (e *TagInputButton) SetX(x int) (ref *TagInputButton)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputButton) SetXY 

func (e *TagInputButton) SetXY(x, y int) (ref *TagInputButton)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputButton) SetY 

func (e *TagInputButton) SetY(y int) (ref *TagInputButton)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputButton) Slot 

func (e *TagInputButton) Slot(slot string) (ref *TagInputButton)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputButton) Spellcheck 

func (e *TagInputButton) Spellcheck(spell bool) (ref *TagInputButton)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputButton) Style 

func (e *TagInputButton) Style(style string) (ref *TagInputButton)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputButton) TabIndex 

func (e *TagInputButton) TabIndex(index int) (ref *TagInputButton)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputButton) Title 

func (e *TagInputButton) Title(title string) (ref *TagInputButton)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputButton) Translate 

func (e *TagInputButton) Translate(translate Translate) (ref *TagInputButton)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputButton) Type 

func (e *TagInputButton) Type(inputType InputType) (ref *TagInputButton)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputButton) Value 

func (e *TagInputButton) Value(value string) (ref *TagInputButton)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputCheckBox 

type TagInputCheckBox struct {
	// contains filtered or unexported fields
}

func (*TagInputCheckBox) AccessKey 

func (e *TagInputCheckBox) AccessKey(key string) (ref *TagInputCheckBox)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputCheckBox) Append 

func (e *TagInputCheckBox) Append(append interface{}) (ref *TagInputCheckBox)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputCheckBox) AppendById 

func (e *TagInputCheckBox) AppendById(appendId string) (ref *TagInputCheckBox)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputCheckBox) Autocomplete 

func (e *TagInputCheckBox) Autocomplete(autocomplete Autocomplete) (ref *TagInputCheckBox)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputCheckBox) Autofocus 

func (e *TagInputCheckBox) Autofocus(autofocus bool) (ref *TagInputCheckBox)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputCheckBox) Checked 

func (e *TagInputCheckBox) Checked(checked bool) (ref *TagInputCheckBox)

Checked

English: 

Valid for both radio and checkbox types, checked is a Boolean attribute. If present on a radio
type, it indicates that the radio button is the currently selected one in the group of same-named
radio buttons. If present on a checkbox type, it indicates that the checkbox is checked by default
(when the page loads).
It does not indicate whether this checkbox is currently checked: if the checkbox's state is
changed, this content attribute does not reflect the change.
(Only the HTMLInputElement's checked IDL attribute is updated.)

 Note:
   * Unlike other input controls, a checkboxes and radio buttons value are only included in the
     submitted data if they are currently checked. If they are, the name and the value(s) of the
     checked controls are submitted.
     For example, if a checkbox whose name is fruit has a value of cherry, and the checkbox is
     checked, the form data submitted will include fruit=cherry. If the checkbox isn't active,
     it isn't listed in the form data at all. The default value for checkboxes and radio buttons
     is on.

Português: 

Válido para os tipos de rádio e caixa de seleção, marcado é um atributo booleano. Se estiver
presente em um tipo de rádio, indica que o botão de opção é o selecionado atualmente no grupo de
botões de opção com o mesmo nome. Se estiver presente em um tipo de caixa de seleção, indica que
a caixa de seleção está marcada por padrão (quando a página é carregada). Não indica se esta caixa
de seleção está marcada no momento: se o estado da caixa de seleção for alterado, esse atributo
de conteúdo não reflete a alteração.
(Apenas o atributo IDL verificado do HTMLInputElement é atualizado.)

 Nota:
   * Ao contrário de outros controles de entrada, um valor de caixas de seleção e botões de opção
     só são incluídos nos dados enviados se estiverem marcados no momento. Se estiverem, o nome e
     o(s) valor(es) dos controles verificados são enviados.
     Por exemplo, se uma caixa de seleção cujo nome é fruta tiver o valor cereja e a caixa de
     seleção estiver marcada, os dados do formulário enviados incluirão fruta=cereja.
     Se a caixa de seleção não estiver ativa, ela não está listada nos dados do formulário.
     O valor padrão para caixas de seleção e botões de opção é ativado.

func (*TagInputCheckBox) Class 

func (e *TagInputCheckBox) Class(class ...string) (ref *TagInputCheckBox)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputCheckBox) ContentEditable 

func (e *TagInputCheckBox) ContentEditable(editable bool) (ref *TagInputCheckBox)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputCheckBox) CreateElement 

func (e *TagInputCheckBox) CreateElement(tag Tag) (ref *TagInputCheckBox)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputCheckBox) Data 

func (e *TagInputCheckBox) Data(data map[string]string) (ref *TagInputCheckBox)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputCheckBox) Dir 

func (e *TagInputCheckBox) Dir(dir Dir) (ref *TagInputCheckBox)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputCheckBox) Disabled 

func (e *TagInputCheckBox) Disabled(disabled bool) (ref *TagInputCheckBox)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputCheckBox) Draggable 

func (e *TagInputCheckBox) Draggable(draggable Draggable) (ref *TagInputCheckBox)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputCheckBox) EnterKeyHint 

func (e *TagInputCheckBox) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputCheckBox)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputCheckBox) Form 

func (e *TagInputCheckBox) Form(form string) (ref *TagInputCheckBox)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputCheckBox) GetX 

func (e *TagInputCheckBox) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputCheckBox) GetXY 

func (e *TagInputCheckBox) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputCheckBox) GetY 

func (e *TagInputCheckBox) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputCheckBox) Hidden 

func (e *TagInputCheckBox) Hidden() (ref *TagInputCheckBox)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputCheckBox) Id 

func (e *TagInputCheckBox) Id(id string) (ref *TagInputCheckBox)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputCheckBox) InputMode 

func (e *TagInputCheckBox) InputMode(inputMode InputMode) (ref *TagInputCheckBox)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputCheckBox) Is 

func (e *TagInputCheckBox) Is(is string) (ref *TagInputCheckBox)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputCheckBox) ItemDrop 

func (e *TagInputCheckBox) ItemDrop(itemprop string) (ref *TagInputCheckBox)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputCheckBox) ItemId 

func (e *TagInputCheckBox) ItemId(id string) (ref *TagInputCheckBox)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputCheckBox) ItemRef 

func (e *TagInputCheckBox) ItemRef(itemref string) (ref *TagInputCheckBox)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputCheckBox) ItemType 

func (e *TagInputCheckBox) ItemType(itemType string) (ref *TagInputCheckBox)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputCheckBox) Lang 

func (e *TagInputCheckBox) Lang(language Language) (ref *TagInputCheckBox)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputCheckBox) List 

func (e *TagInputCheckBox) List(list string) (ref *TagInputCheckBox)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputCheckBox) Name 

func (e *TagInputCheckBox) Name(name string) (ref *TagInputCheckBox)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputCheckBox) Nonce 

func (e *TagInputCheckBox) Nonce(part ...string) (ref *TagInputCheckBox)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputCheckBox) ReadOnly 

func (e *TagInputCheckBox) ReadOnly(readonly bool) (ref *TagInputCheckBox)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputCheckBox) Required 

func (e *TagInputCheckBox) Required(required bool) (ref *TagInputCheckBox)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputCheckBox) SetX 

func (e *TagInputCheckBox) SetX(x int) (ref *TagInputCheckBox)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputCheckBox) SetXY 

func (e *TagInputCheckBox) SetXY(x, y int) (ref *TagInputCheckBox)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputCheckBox) SetY 

func (e *TagInputCheckBox) SetY(y int) (ref *TagInputCheckBox)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputCheckBox) Slot 

func (e *TagInputCheckBox) Slot(slot string) (ref *TagInputCheckBox)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputCheckBox) Spellcheck 

func (e *TagInputCheckBox) Spellcheck(spell bool) (ref *TagInputCheckBox)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputCheckBox) Style 

func (e *TagInputCheckBox) Style(style string) (ref *TagInputCheckBox)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputCheckBox) TabIndex 

func (e *TagInputCheckBox) TabIndex(index int) (ref *TagInputCheckBox)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputCheckBox) Title 

func (e *TagInputCheckBox) Title(title string) (ref *TagInputCheckBox)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputCheckBox) Translate 

func (e *TagInputCheckBox) Translate(translate Translate) (ref *TagInputCheckBox)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputCheckBox) Type 

func (e *TagInputCheckBox) Type(inputType InputType) (ref *TagInputCheckBox)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputCheckBox) Value 

func (e *TagInputCheckBox) Value(value string) (ref *TagInputCheckBox)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputColor 

type TagInputColor struct {
	// contains filtered or unexported fields
}

func (*TagInputColor) AccessKey 

func (e *TagInputColor) AccessKey(key string) (ref *TagInputColor)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputColor) Append 

func (e *TagInputColor) Append(append interface{}) (ref *TagInputColor)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputColor) AppendById 

func (e *TagInputColor) AppendById(appendId string) (ref *TagInputColor)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputColor) Autocomplete 

func (e *TagInputColor) Autocomplete(autocomplete Autocomplete) (ref *TagInputColor)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputColor) Autofocus 

func (e *TagInputColor) Autofocus(autofocus bool) (ref *TagInputColor)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputColor) Class 

func (e *TagInputColor) Class(class ...string) (ref *TagInputColor)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputColor) ContentEditable 

func (e *TagInputColor) ContentEditable(editable bool) (ref *TagInputColor)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputColor) CreateElement 

func (e *TagInputColor) CreateElement(tag Tag) (ref *TagInputColor)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputColor) Data 

func (e *TagInputColor) Data(data map[string]string) (ref *TagInputColor)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputColor) Dir 

func (e *TagInputColor) Dir(dir Dir) (ref *TagInputColor)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputColor) Disabled 

func (e *TagInputColor) Disabled(disabled bool) (ref *TagInputColor)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputColor) Draggable 

func (e *TagInputColor) Draggable(draggable Draggable) (ref *TagInputColor)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputColor) EnterKeyHint 

func (e *TagInputColor) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputColor)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputColor) Form 

func (e *TagInputColor) Form(form string) (ref *TagInputColor)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputColor) GetX 

func (e *TagInputColor) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputColor) GetXY 

func (e *TagInputColor) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputColor) GetY 

func (e *TagInputColor) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputColor) Hidden 

func (e *TagInputColor) Hidden() (ref *TagInputColor)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputColor) Id 

func (e *TagInputColor) Id(id string) (ref *TagInputColor)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputColor) InputMode 

func (e *TagInputColor) InputMode(inputMode InputMode) (ref *TagInputColor)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputColor) Is 

func (e *TagInputColor) Is(is string) (ref *TagInputColor)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputColor) ItemDrop 

func (e *TagInputColor) ItemDrop(itemprop string) (ref *TagInputColor)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputColor) ItemId 

func (e *TagInputColor) ItemId(id string) (ref *TagInputColor)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputColor) ItemRef 

func (e *TagInputColor) ItemRef(itemref string) (ref *TagInputColor)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputColor) ItemType 

func (e *TagInputColor) ItemType(itemType string) (ref *TagInputColor)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputColor) Lang 

func (e *TagInputColor) Lang(language Language) (ref *TagInputColor)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputColor) List 

func (e *TagInputColor) List(list string) (ref *TagInputColor)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputColor) Max 

func (e *TagInputColor) Max(max int) (ref *TagInputColor)

Max

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the greatest
value in the range of permitted values.
If the value entered into the element exceeds this, the element fails constraint validation.
If the value of the max attribute isn't a number, then the element has no maximum value.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, datetime-local, número e intervalo, define o maior valor no
intervalo de valores permitidos. Se o valor inserido no elemento exceder isso, o elemento falhará
na validação de restrição. Se o valor do atributo max não for um número, o elemento não terá
valor máximo.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputColor) Min 

func (e *TagInputColor) Min(min int) (ref *TagInputColor)

Min

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the most negative
value in the range of permitted values.

If the value entered into the element is less than this, the element fails constraint validation. If the value of the min attribute isn't a number, then the element has no minimum value.

This value must be less than or equal to the value of the max attribute. If the min attribute is present but is not specified or is invalid, no min value is applied. If the min attribute is valid and a non-empty value is less than the minimum allowed by the min attribute, constraint validation will prevent form submission. See Client-side validation for more information.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, data e hora local, número e intervalo, define o valor mais
negativo no intervalo de valores permitidos.

Se o valor inserido no elemento for menor que isso, o elemento falhará na validação de restrição. Se o valor do atributo min não for um número, o elemento não terá valor mínimo.

Esse valor deve ser menor ou igual ao valor do atributo max. Se o atributo min estiver presente, mas não for especificado ou for inválido, nenhum valor min será aplicado. Se o atributo min for válido e um valor não vazio for menor que o mínimo permitido pelo atributo min, a validação de restrição impedirá o envio do formulário. Consulte Validação do lado do cliente para obter mais informações.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputColor) MinLength 

func (e *TagInputColor) MinLength(minlength int) (ref *TagInputColor)

MinLength

English: 

Valid for text, search, url, tel, email, and password, it defines the minimum number of
characters (as UTF-16 code units) the user can enter into the entry field.

This must be an non-negative integer value smaller than or equal to the value specified by maxlength. If no minlength is specified, or an invalid value is specified, the input has no minimum length.

The input will fail constraint validation if the length of the text entered into the field is fewer than minlength UTF-16 code units long, preventing form submission.

Português: 

Válido para texto, pesquisa, url, tel, email e senha, define o número mínimo de caracteres
(como unidades de código UTF-16) que o usuário pode inserir no campo de entrada.

Este deve ser um valor inteiro não negativo menor ou igual ao valor especificado por maxlength. Se nenhum comprimento mínimo for especificado ou um valor inválido for especificado, a entrada não terá comprimento mínimo.

A entrada falhará na validação de restrição se o comprimento do texto inserido no campo for inferior a unidades de código UTF-16 de comprimento mínimo, impedindo o envio do formulário.

func (*TagInputColor) Name 

func (e *TagInputColor) Name(name string) (ref *TagInputColor)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputColor) Nonce 

func (e *TagInputColor) Nonce(part ...string) (ref *TagInputColor)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputColor) ReadOnly 

func (e *TagInputColor) ReadOnly(readonly bool) (ref *TagInputColor)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputColor) Required 

func (e *TagInputColor) Required(required bool) (ref *TagInputColor)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputColor) SetX 

func (e *TagInputColor) SetX(x int) (ref *TagInputColor)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputColor) SetXY 

func (e *TagInputColor) SetXY(x, y int) (ref *TagInputColor)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputColor) SetY 

func (e *TagInputColor) SetY(y int) (ref *TagInputColor)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputColor) Slot 

func (e *TagInputColor) Slot(slot string) (ref *TagInputColor)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputColor) Spellcheck 

func (e *TagInputColor) Spellcheck(spell bool) (ref *TagInputColor)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputColor) Step 

func (e *TagInputColor) Step(step int) (ref *TagInputColor)

Step

English: 

Valid for the numeric input types, including number, date/time input types, and range, the step
attribute is a number that specifies the granularity that the value must adhere to.

 If not explicitly included:
   * step defaults to 1 for number and range;
   * For the date/time input types, step is expressed in seconds, with the default step being 60
     seconds. The step scale factor is 1000 (which converts the seconds to milliseconds, as used
     in other algorithms);
   * The value must be a positive number—integer or float—or the special value any, which means
     no stepping is implied, and any value is allowed (barring other constraints, such as min and
     max).

If any is not explicitly set, valid values for the number, date/time input types, and range input types are equal to the basis for stepping — the min value and increments of the step value, up to the max value, if specified.

For example, if you have <input type="number" min="10" step="2">, then any even integer, 10 or greater, is valid. If omitted, <input type="number">, any integer is valid, but floats (like 4.2) are not valid, because step defaults to 1. For 4.2 to be valid, step would have had to be set to any, 0.1, 0.2, or any the min value would have had to be a number ending in .2, such as <input type="number" min="-5.2"> 

Note:
  * When the data entered by the user doesn't adhere to the stepping configuration, the value is
    considered invalid in constraint validation and will match the :invalid pseudoclass.

Português: 

Válido para os tipos de entrada numérica, incluindo número, tipos de entrada de data e hora e
intervalo, o atributo step é um número que especifica a granularidade à qual o valor deve aderir.

 Se não estiver explicitamente incluído:
   * step padroniza para 1 para número e intervalo.
   * Para os tipos de entrada de data e hora, a etapa é expressa em segundos, com a etapa padrão
     sendo 60 segundos. O fator de escala de passo é 1000 (que converte os segundos em
     milissegundos, conforme usado em outros algoritmos).
   * O valor deve ser um número positivo — inteiro ou flutuante — ou o valor especial any, o que
     significa que nenhuma depuração está implícita e qualquer valor é permitido (exceto outras
     restrições, como min e max).

Se algum não for definido explicitamente, os valores válidos para o número, tipos de entrada de data e hora e tipos de entrada de intervalo são iguais à base para a depuração — o valor mínimo e os incrementos do valor da etapa, até o valor máximo, se especificado.

Por exemplo, se você tiver <input type="number" min="10" step="2">, qualquer número inteiro par, 10 ou maior, é válido. Se omitido, <input type="number">, qualquer inteiro é válido, mas floats (como 4.2) não são válidos, porque step é padronizado como 1. Para 4.2 ser válido, step teria que ser definido como any, 0.1 , 0.2 ou qualquer valor mínimo teria que ser um número que terminasse em .2, como <input type="number" min="-5.2"> 

Nota:
  * Quando os dados inseridos pelo usuário não estão de acordo com a configuração de stepping,
    o valor é considerado inválido na validação da restrição e corresponderá à
    :invalid pseudoclass.

func (*TagInputColor) Style 

func (e *TagInputColor) Style(style string) (ref *TagInputColor)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputColor) TabIndex 

func (e *TagInputColor) TabIndex(index int) (ref *TagInputColor)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputColor) Title 

func (e *TagInputColor) Title(title string) (ref *TagInputColor)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputColor) Translate 

func (e *TagInputColor) Translate(translate Translate) (ref *TagInputColor)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputColor) Type 

func (e *TagInputColor) Type(inputType InputType) (ref *TagInputColor)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputColor) Value 

func (e *TagInputColor) Value(value string) (ref *TagInputColor)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputDate 

type TagInputDate struct {
	// contains filtered or unexported fields
}

func (*TagInputDate) AccessKey 

func (e *TagInputDate) AccessKey(key string) (ref *TagInputDate)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputDate) Append 

func (e *TagInputDate) Append(append interface{}) (ref *TagInputDate)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputDate) AppendById 

func (e *TagInputDate) AppendById(appendId string) (ref *TagInputDate)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputDate) Autocomplete 

func (e *TagInputDate) Autocomplete(autocomplete Autocomplete) (ref *TagInputDate)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputDate) Autofocus 

func (e *TagInputDate) Autofocus(autofocus bool) (ref *TagInputDate)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputDate) Class 

func (e *TagInputDate) Class(class ...string) (ref *TagInputDate)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputDate) ContentEditable 

func (e *TagInputDate) ContentEditable(editable bool) (ref *TagInputDate)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputDate) CreateElement 

func (e *TagInputDate) CreateElement(tag Tag) (ref *TagInputDate)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputDate) Data 

func (e *TagInputDate) Data(data map[string]string) (ref *TagInputDate)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputDate) Dir 

func (e *TagInputDate) Dir(dir Dir) (ref *TagInputDate)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputDate) Disabled 

func (e *TagInputDate) Disabled(disabled bool) (ref *TagInputDate)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputDate) Draggable 

func (e *TagInputDate) Draggable(draggable Draggable) (ref *TagInputDate)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputDate) EnterKeyHint 

func (e *TagInputDate) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputDate)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputDate) Form 

func (e *TagInputDate) Form(form string) (ref *TagInputDate)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputDate) GetX 

func (e *TagInputDate) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputDate) GetXY 

func (e *TagInputDate) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputDate) GetY 

func (e *TagInputDate) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputDate) Hidden 

func (e *TagInputDate) Hidden() (ref *TagInputDate)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputDate) Id 

func (e *TagInputDate) Id(id string) (ref *TagInputDate)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputDate) InputMode 

func (e *TagInputDate) InputMode(inputMode InputMode) (ref *TagInputDate)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputDate) Is 

func (e *TagInputDate) Is(is string) (ref *TagInputDate)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputDate) ItemDrop 

func (e *TagInputDate) ItemDrop(itemprop string) (ref *TagInputDate)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputDate) ItemId 

func (e *TagInputDate) ItemId(id string) (ref *TagInputDate)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputDate) ItemRef 

func (e *TagInputDate) ItemRef(itemref string) (ref *TagInputDate)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputDate) ItemType 

func (e *TagInputDate) ItemType(itemType string) (ref *TagInputDate)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputDate) Lang 

func (e *TagInputDate) Lang(language Language) (ref *TagInputDate)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputDate) List 

func (e *TagInputDate) List(list string) (ref *TagInputDate)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputDate) Max 

func (e *TagInputDate) Max(max int) (ref *TagInputDate)

Max

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the greatest
value in the range of permitted values.
If the value entered into the element exceeds this, the element fails constraint validation.
If the value of the max attribute isn't a number, then the element has no maximum value.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, datetime-local, número e intervalo, define o maior valor no
intervalo de valores permitidos. Se o valor inserido no elemento exceder isso, o elemento falhará
na validação de restrição. Se o valor do atributo max não for um número, o elemento não terá
valor máximo.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputDate) Min 

func (e *TagInputDate) Min(min int) (ref *TagInputDate)

Min

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the most negative
value in the range of permitted values.

If the value entered into the element is less than this, the element fails constraint validation. If the value of the min attribute isn't a number, then the element has no minimum value.

This value must be less than or equal to the value of the max attribute. If the min attribute is present but is not specified or is invalid, no min value is applied. If the min attribute is valid and a non-empty value is less than the minimum allowed by the min attribute, constraint validation will prevent form submission. See Client-side validation for more information.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, data e hora local, número e intervalo, define o valor mais
negativo no intervalo de valores permitidos.

Se o valor inserido no elemento for menor que isso, o elemento falhará na validação de restrição. Se o valor do atributo min não for um número, o elemento não terá valor mínimo.

Esse valor deve ser menor ou igual ao valor do atributo max. Se o atributo min estiver presente, mas não for especificado ou for inválido, nenhum valor min será aplicado. Se o atributo min for válido e um valor não vazio for menor que o mínimo permitido pelo atributo min, a validação de restrição impedirá o envio do formulário. Consulte Validação do lado do cliente para obter mais informações.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputDate) Name 

func (e *TagInputDate) Name(name string) (ref *TagInputDate)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputDate) Nonce 

func (e *TagInputDate) Nonce(part ...string) (ref *TagInputDate)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputDate) ReadOnly 

func (e *TagInputDate) ReadOnly(readonly bool) (ref *TagInputDate)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputDate) Required 

func (e *TagInputDate) Required(required bool) (ref *TagInputDate)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputDate) SetX 

func (e *TagInputDate) SetX(x int) (ref *TagInputDate)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputDate) SetXY 

func (e *TagInputDate) SetXY(x, y int) (ref *TagInputDate)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputDate) SetY 

func (e *TagInputDate) SetY(y int) (ref *TagInputDate)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputDate) Slot 

func (e *TagInputDate) Slot(slot string) (ref *TagInputDate)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputDate) Spellcheck 

func (e *TagInputDate) Spellcheck(spell bool) (ref *TagInputDate)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputDate) Step 

func (e *TagInputDate) Step(step int) (ref *TagInputDate)

Step

English: 

Valid for the numeric input types, including number, date/time input types, and range, the step
attribute is a number that specifies the granularity that the value must adhere to.

 If not explicitly included:
   * step defaults to 1 for number and range;
   * For the date/time input types, step is expressed in seconds, with the default step being 60
     seconds. The step scale factor is 1000 (which converts the seconds to milliseconds, as used
     in other algorithms);
   * The value must be a positive number—integer or float—or the special value any, which means
     no stepping is implied, and any value is allowed (barring other constraints, such as min and
     max).

If any is not explicitly set, valid values for the number, date/time input types, and range input types are equal to the basis for stepping — the min value and increments of the step value, up to the max value, if specified.

For example, if you have <input type="number" min="10" step="2">, then any even integer, 10 or greater, is valid. If omitted, <input type="number">, any integer is valid, but floats (like 4.2) are not valid, because step defaults to 1. For 4.2 to be valid, step would have had to be set to any, 0.1, 0.2, or any the min value would have had to be a number ending in .2, such as <input type="number" min="-5.2"> 

Note:
  * When the data entered by the user doesn't adhere to the stepping configuration, the value is
    considered invalid in constraint validation and will match the :invalid pseudoclass.

Português: 

Válido para os tipos de entrada numérica, incluindo número, tipos de entrada de data e hora e
intervalo, o atributo step é um número que especifica a granularidade à qual o valor deve aderir.

 Se não estiver explicitamente incluído:
   * step padroniza para 1 para número e intervalo.
   * Para os tipos de entrada de data e hora, a etapa é expressa em segundos, com a etapa padrão
     sendo 60 segundos. O fator de escala de passo é 1000 (que converte os segundos em
     milissegundos, conforme usado em outros algoritmos).
   * O valor deve ser um número positivo — inteiro ou flutuante — ou o valor especial any, o que
     significa que nenhuma depuração está implícita e qualquer valor é permitido (exceto outras
     restrições, como min e max).

Se algum não for definido explicitamente, os valores válidos para o número, tipos de entrada de data e hora e tipos de entrada de intervalo são iguais à base para a depuração — o valor mínimo e os incrementos do valor da etapa, até o valor máximo, se especificado.

Por exemplo, se você tiver <input type="number" min="10" step="2">, qualquer número inteiro par, 10 ou maior, é válido. Se omitido, <input type="number">, qualquer inteiro é válido, mas floats (como 4.2) não são válidos, porque step é padronizado como 1. Para 4.2 ser válido, step teria que ser definido como any, 0.1 , 0.2 ou qualquer valor mínimo teria que ser um número que terminasse em .2, como <input type="number" min="-5.2"> 

Nota:
  * Quando os dados inseridos pelo usuário não estão de acordo com a configuração de stepping,
    o valor é considerado inválido na validação da restrição e corresponderá à
    :invalid pseudoclass.

func (*TagInputDate) Style 

func (e *TagInputDate) Style(style string) (ref *TagInputDate)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputDate) TabIndex 

func (e *TagInputDate) TabIndex(index int) (ref *TagInputDate)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputDate) Title 

func (e *TagInputDate) Title(title string) (ref *TagInputDate)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputDate) Translate 

func (e *TagInputDate) Translate(translate Translate) (ref *TagInputDate)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputDate) Type 

func (e *TagInputDate) Type(inputType InputType) (ref *TagInputDate)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputDate) Value 

func (e *TagInputDate) Value(value string) (ref *TagInputDate)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputDateTimeLocal 

type TagInputDateTimeLocal struct {
	// contains filtered or unexported fields
}

func (*TagInputDateTimeLocal) AccessKey 

func (e *TagInputDateTimeLocal) AccessKey(key string) (ref *TagInputDateTimeLocal)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputDateTimeLocal) Append 

func (e *TagInputDateTimeLocal) Append(append interface{}) (ref *TagInputDateTimeLocal)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputDateTimeLocal) AppendById 

func (e *TagInputDateTimeLocal) AppendById(appendId string) (ref *TagInputDateTimeLocal)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputDateTimeLocal) Autocomplete 

func (e *TagInputDateTimeLocal) Autocomplete(autocomplete Autocomplete) (ref *TagInputDateTimeLocal)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputDateTimeLocal) Autofocus 

func (e *TagInputDateTimeLocal) Autofocus(autofocus bool) (ref *TagInputDateTimeLocal)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputDateTimeLocal) Class 

func (e *TagInputDateTimeLocal) Class(class ...string) (ref *TagInputDateTimeLocal)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputDateTimeLocal) ContentEditable 

func (e *TagInputDateTimeLocal) ContentEditable(editable bool) (ref *TagInputDateTimeLocal)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputDateTimeLocal) CreateElement 

func (e *TagInputDateTimeLocal) CreateElement(tag Tag) (ref *TagInputDateTimeLocal)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputDateTimeLocal) Data 

func (e *TagInputDateTimeLocal) Data(data map[string]string) (ref *TagInputDateTimeLocal)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputDateTimeLocal) Dir 

func (e *TagInputDateTimeLocal) Dir(dir Dir) (ref *TagInputDateTimeLocal)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputDateTimeLocal) Disabled 

func (e *TagInputDateTimeLocal) Disabled(disabled bool) (ref *TagInputDateTimeLocal)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputDateTimeLocal) Draggable 

func (e *TagInputDateTimeLocal) Draggable(draggable Draggable) (ref *TagInputDateTimeLocal)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputDateTimeLocal) EnterKeyHint 

func (e *TagInputDateTimeLocal) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputDateTimeLocal)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputDateTimeLocal) Form 

func (e *TagInputDateTimeLocal) Form(form string) (ref *TagInputDateTimeLocal)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputDateTimeLocal) GetX 

func (e *TagInputDateTimeLocal) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputDateTimeLocal) GetXY 

func (e *TagInputDateTimeLocal) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputDateTimeLocal) GetY 

func (e *TagInputDateTimeLocal) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputDateTimeLocal) Hidden 

func (e *TagInputDateTimeLocal) Hidden() (ref *TagInputDateTimeLocal)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputDateTimeLocal) Id 

func (e *TagInputDateTimeLocal) Id(id string) (ref *TagInputDateTimeLocal)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputDateTimeLocal) InputMode 

func (e *TagInputDateTimeLocal) InputMode(inputMode InputMode) (ref *TagInputDateTimeLocal)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputDateTimeLocal) Is 

func (e *TagInputDateTimeLocal) Is(is string) (ref *TagInputDateTimeLocal)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputDateTimeLocal) ItemDrop 

func (e *TagInputDateTimeLocal) ItemDrop(itemprop string) (ref *TagInputDateTimeLocal)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputDateTimeLocal) ItemId 

func (e *TagInputDateTimeLocal) ItemId(id string) (ref *TagInputDateTimeLocal)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputDateTimeLocal) ItemRef 

func (e *TagInputDateTimeLocal) ItemRef(itemref string) (ref *TagInputDateTimeLocal)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputDateTimeLocal) ItemType 

func (e *TagInputDateTimeLocal) ItemType(itemType string) (ref *TagInputDateTimeLocal)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputDateTimeLocal) Lang 

func (e *TagInputDateTimeLocal) Lang(language Language) (ref *TagInputDateTimeLocal)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputDateTimeLocal) List 

func (e *TagInputDateTimeLocal) List(list string) (ref *TagInputDateTimeLocal)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputDateTimeLocal) Max 

func (e *TagInputDateTimeLocal) Max(max int) (ref *TagInputDateTimeLocal)

Max

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the greatest
value in the range of permitted values.
If the value entered into the element exceeds this, the element fails constraint validation.
If the value of the max attribute isn't a number, then the element has no maximum value.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, datetime-local, número e intervalo, define o maior valor no
intervalo de valores permitidos. Se o valor inserido no elemento exceder isso, o elemento falhará
na validação de restrição. Se o valor do atributo max não for um número, o elemento não terá
valor máximo.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputDateTimeLocal) Min 

func (e *TagInputDateTimeLocal) Min(min int) (ref *TagInputDateTimeLocal)

Min

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the most negative
value in the range of permitted values.

If the value entered into the element is less than this, the element fails constraint validation. If the value of the min attribute isn't a number, then the element has no minimum value.

This value must be less than or equal to the value of the max attribute. If the min attribute is present but is not specified or is invalid, no min value is applied. If the min attribute is valid and a non-empty value is less than the minimum allowed by the min attribute, constraint validation will prevent form submission. See Client-side validation for more information.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, data e hora local, número e intervalo, define o valor mais
negativo no intervalo de valores permitidos.

Se o valor inserido no elemento for menor que isso, o elemento falhará na validação de restrição. Se o valor do atributo min não for um número, o elemento não terá valor mínimo.

Esse valor deve ser menor ou igual ao valor do atributo max. Se o atributo min estiver presente, mas não for especificado ou for inválido, nenhum valor min será aplicado. Se o atributo min for válido e um valor não vazio for menor que o mínimo permitido pelo atributo min, a validação de restrição impedirá o envio do formulário. Consulte Validação do lado do cliente para obter mais informações.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputDateTimeLocal) Name 

func (e *TagInputDateTimeLocal) Name(name string) (ref *TagInputDateTimeLocal)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputDateTimeLocal) Nonce 

func (e *TagInputDateTimeLocal) Nonce(part ...string) (ref *TagInputDateTimeLocal)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputDateTimeLocal) ReadOnly 

func (e *TagInputDateTimeLocal) ReadOnly(readonly bool) (ref *TagInputDateTimeLocal)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputDateTimeLocal) Required 

func (e *TagInputDateTimeLocal) Required(required bool) (ref *TagInputDateTimeLocal)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputDateTimeLocal) SetX 

func (e *TagInputDateTimeLocal) SetX(x int) (ref *TagInputDateTimeLocal)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputDateTimeLocal) SetXY 

func (e *TagInputDateTimeLocal) SetXY(x, y int) (ref *TagInputDateTimeLocal)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputDateTimeLocal) SetY 

func (e *TagInputDateTimeLocal) SetY(y int) (ref *TagInputDateTimeLocal)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputDateTimeLocal) Slot 

func (e *TagInputDateTimeLocal) Slot(slot string) (ref *TagInputDateTimeLocal)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputDateTimeLocal) Spellcheck 

func (e *TagInputDateTimeLocal) Spellcheck(spell bool) (ref *TagInputDateTimeLocal)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputDateTimeLocal) Step 

func (e *TagInputDateTimeLocal) Step(step int) (ref *TagInputDateTimeLocal)

Step

English: 

Valid for the numeric input types, including number, date/time input types, and range, the step
attribute is a number that specifies the granularity that the value must adhere to.

 If not explicitly included:
   * step defaults to 1 for number and range;
   * For the date/time input types, step is expressed in seconds, with the default step being 60
     seconds. The step scale factor is 1000 (which converts the seconds to milliseconds, as used
     in other algorithms);
   * The value must be a positive number—integer or float—or the special value any, which means
     no stepping is implied, and any value is allowed (barring other constraints, such as min and
     max).

If any is not explicitly set, valid values for the number, date/time input types, and range input types are equal to the basis for stepping — the min value and increments of the step value, up to the max value, if specified.

For example, if you have <input type="number" min="10" step="2">, then any even integer, 10 or greater, is valid. If omitted, <input type="number">, any integer is valid, but floats (like 4.2) are not valid, because step defaults to 1. For 4.2 to be valid, step would have had to be set to any, 0.1, 0.2, or any the min value would have had to be a number ending in .2, such as <input type="number" min="-5.2"> 

Note:
  * When the data entered by the user doesn't adhere to the stepping configuration, the value is
    considered invalid in constraint validation and will match the :invalid pseudoclass.

Português: 

Válido para os tipos de entrada numérica, incluindo número, tipos de entrada de data e hora e
intervalo, o atributo step é um número que especifica a granularidade à qual o valor deve aderir.

 Se não estiver explicitamente incluído:
   * step padroniza para 1 para número e intervalo.
   * Para os tipos de entrada de data e hora, a etapa é expressa em segundos, com a etapa padrão
     sendo 60 segundos. O fator de escala de passo é 1000 (que converte os segundos em
     milissegundos, conforme usado em outros algoritmos).
   * O valor deve ser um número positivo — inteiro ou flutuante — ou o valor especial any, o que
     significa que nenhuma depuração está implícita e qualquer valor é permitido (exceto outras
     restrições, como min e max).

Se algum não for definido explicitamente, os valores válidos para o número, tipos de entrada de data e hora e tipos de entrada de intervalo são iguais à base para a depuração — o valor mínimo e os incrementos do valor da etapa, até o valor máximo, se especificado.

Por exemplo, se você tiver <input type="number" min="10" step="2">, qualquer número inteiro par, 10 ou maior, é válido. Se omitido, <input type="number">, qualquer inteiro é válido, mas floats (como 4.2) não são válidos, porque step é padronizado como 1. Para 4.2 ser válido, step teria que ser definido como any, 0.1 , 0.2 ou qualquer valor mínimo teria que ser um número que terminasse em .2, como <input type="number" min="-5.2"> 

Nota:
  * Quando os dados inseridos pelo usuário não estão de acordo com a configuração de stepping,
    o valor é considerado inválido na validação da restrição e corresponderá à
    :invalid pseudoclass.

func (*TagInputDateTimeLocal) Style 

func (e *TagInputDateTimeLocal) Style(style string) (ref *TagInputDateTimeLocal)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputDateTimeLocal) TabIndex 

func (e *TagInputDateTimeLocal) TabIndex(index int) (ref *TagInputDateTimeLocal)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputDateTimeLocal) Title 

func (e *TagInputDateTimeLocal) Title(title string) (ref *TagInputDateTimeLocal)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputDateTimeLocal) Translate 

func (e *TagInputDateTimeLocal) Translate(translate Translate) (ref *TagInputDateTimeLocal)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputDateTimeLocal) Type 

func (e *TagInputDateTimeLocal) Type(inputType InputType) (ref *TagInputDateTimeLocal)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputDateTimeLocal) Value 

func (e *TagInputDateTimeLocal) Value(value string) (ref *TagInputDateTimeLocal)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputEMail 

type TagInputEMail struct {
	// contains filtered or unexported fields
}

func (*TagInputEMail) AccessKey 

func (e *TagInputEMail) AccessKey(key string) (ref *TagInputEMail)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputEMail) Append 

func (e *TagInputEMail) Append(append interface{}) (ref *TagInputEMail)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputEMail) AppendById 

func (e *TagInputEMail) AppendById(appendId string) (ref *TagInputEMail)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputEMail) Autocomplete 

func (e *TagInputEMail) Autocomplete(autocomplete Autocomplete) (ref *TagInputEMail)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputEMail) Autofocus 

func (e *TagInputEMail) Autofocus(autofocus bool) (ref *TagInputEMail)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputEMail) Class 

func (e *TagInputEMail) Class(class ...string) (ref *TagInputEMail)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputEMail) ContentEditable 

func (e *TagInputEMail) ContentEditable(editable bool) (ref *TagInputEMail)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputEMail) CreateElement 

func (e *TagInputEMail) CreateElement(tag Tag) (ref *TagInputEMail)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputEMail) Data 

func (e *TagInputEMail) Data(data map[string]string) (ref *TagInputEMail)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputEMail) Dir 

func (e *TagInputEMail) Dir(dir Dir) (ref *TagInputEMail)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputEMail) Disabled 

func (e *TagInputEMail) Disabled(disabled bool) (ref *TagInputEMail)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputEMail) Draggable 

func (e *TagInputEMail) Draggable(draggable Draggable) (ref *TagInputEMail)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputEMail) EnterKeyHint 

func (e *TagInputEMail) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputEMail)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputEMail) Form 

func (e *TagInputEMail) Form(form string) (ref *TagInputEMail)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputEMail) GetX 

func (e *TagInputEMail) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputEMail) GetXY 

func (e *TagInputEMail) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputEMail) GetY 

func (e *TagInputEMail) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputEMail) Hidden 

func (e *TagInputEMail) Hidden() (ref *TagInputEMail)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputEMail) Id 

func (e *TagInputEMail) Id(id string) (ref *TagInputEMail)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputEMail) InputMode 

func (e *TagInputEMail) InputMode(inputMode InputMode) (ref *TagInputEMail)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputEMail) Is 

func (e *TagInputEMail) Is(is string) (ref *TagInputEMail)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputEMail) ItemDrop 

func (e *TagInputEMail) ItemDrop(itemprop string) (ref *TagInputEMail)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputEMail) ItemId 

func (e *TagInputEMail) ItemId(id string) (ref *TagInputEMail)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputEMail) ItemRef 

func (e *TagInputEMail) ItemRef(itemref string) (ref *TagInputEMail)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputEMail) ItemType 

func (e *TagInputEMail) ItemType(itemType string) (ref *TagInputEMail)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputEMail) Lang 

func (e *TagInputEMail) Lang(language Language) (ref *TagInputEMail)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputEMail) List 

func (e *TagInputEMail) List(list string) (ref *TagInputEMail)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputEMail) Multiple 

func (e *TagInputEMail) Multiple(multiple bool) (ref *TagInputEMail)

Multiple

English: 

This Boolean attribute indicates that multiple options can be selected in the list. If it is not
specified, then only one option can be selected at a time. When multiple is specified, most
browsers will show a scrolling list box instead of a single line dropdown.

Português: 

Este atributo booleano indica que várias opções podem ser selecionadas na lista. Se não for
especificado, apenas uma opção pode ser selecionada por vez. Quando vários são especificados, a
maioria dos navegadores mostrará uma caixa de listagem de rolagem em vez de uma lista suspensa
de uma única linha.

func (*TagInputEMail) Name 

func (e *TagInputEMail) Name(name string) (ref *TagInputEMail)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputEMail) Nonce 

func (e *TagInputEMail) Nonce(part ...string) (ref *TagInputEMail)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputEMail) ReadOnly 

func (e *TagInputEMail) ReadOnly(readonly bool) (ref *TagInputEMail)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputEMail) Required 

func (e *TagInputEMail) Required(required bool) (ref *TagInputEMail)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputEMail) SetX 

func (e *TagInputEMail) SetX(x int) (ref *TagInputEMail)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputEMail) SetXY 

func (e *TagInputEMail) SetXY(x, y int) (ref *TagInputEMail)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputEMail) SetY 

func (e *TagInputEMail) SetY(y int) (ref *TagInputEMail)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputEMail) Size 

func (e *TagInputEMail) Size(size int) (ref *TagInputEMail)

Size

English: 

If the control is presented as a scrolling list box (e.g. when multiple is specified), this
attribute represents the number of rows in the list that should be visible at one time.
Browsers are not required to present a select element as a scrolled list box. The default value
is 0.

 Note:
   * According to the HTML5 specification, the default value for size should be 1; however, in
     practice, this has been found to break some web sites, and no other browser currently does
     that, so Mozilla has opted to continue to return 0 for the time being with Firefox.

Português: 

Se o controle for apresentado como uma caixa de listagem de rolagem (por exemplo, quando múltiplo
é especificado), esse atributo representa o número de linhas na lista que devem estar visíveis ao
mesmo tempo. Os navegadores não precisam apresentar um elemento de seleção como uma caixa de
listagem rolada. O valor padrão é 0.

 Nota:
   * De acordo com a especificação HTML5, o valor padrão para tamanho deve ser 1; no entanto, na
     prática, descobriu-se que isso quebra alguns sites, e nenhum outro navegador atualmente faz
     isso, então a Mozilla optou por continuar retornando 0 por enquanto com o Firefox.

func (*TagInputEMail) Slot 

func (e *TagInputEMail) Slot(slot string) (ref *TagInputEMail)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputEMail) Spellcheck 

func (e *TagInputEMail) Spellcheck(spell bool) (ref *TagInputEMail)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputEMail) Style 

func (e *TagInputEMail) Style(style string) (ref *TagInputEMail)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputEMail) TabIndex 

func (e *TagInputEMail) TabIndex(index int) (ref *TagInputEMail)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputEMail) Title 

func (e *TagInputEMail) Title(title string) (ref *TagInputEMail)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputEMail) Translate 

func (e *TagInputEMail) Translate(translate Translate) (ref *TagInputEMail)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputEMail) Type 

func (e *TagInputEMail) Type(inputType InputType) (ref *TagInputEMail)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputEMail) Value 

func (e *TagInputEMail) Value(value string) (ref *TagInputEMail)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputFile 

type TagInputFile struct {
	// contains filtered or unexported fields
}

func (*TagInputFile) Accept 

func (e *TagInputFile) Accept(accept string) (ref *TagInputFile)

Accept

English: 

Valid for the file input type only, the accept attribute defines which file types are selectable
in a file upload control. See the file input type.

Português: 

Válido apenas para o tipo de entrada de arquivo, o atributo accept define quais tipos de arquivo
são selecionáveis em um controle de upload de arquivo. Consulte o tipo de entrada do arquivo.

func (*TagInputFile) AccessKey 

func (e *TagInputFile) AccessKey(key string) (ref *TagInputFile)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputFile) Append 

func (e *TagInputFile) Append(append interface{}) (ref *TagInputFile)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputFile) AppendById 

func (e *TagInputFile) AppendById(appendId string) (ref *TagInputFile)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputFile) Autocomplete 

func (e *TagInputFile) Autocomplete(autocomplete Autocomplete) (ref *TagInputFile)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputFile) Autofocus 

func (e *TagInputFile) Autofocus(autofocus bool) (ref *TagInputFile)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputFile) Capture 

func (e *TagInputFile) Capture(capture string) (ref *TagInputFile)

Capture

English: 

Introduced in the HTML Media Capture specification and valid for the file input type only, the
capture attribute defines which media—microphone, video, or camera—should be used to capture a
new file for upload with file upload control in supporting scenarios.

Português: 

Introduzido na especificação HTML Media Capture e válido apenas para o tipo de entrada de arquivo,
o atributo capture define qual mídia—microfone, vídeo ou câmera—deve ser usada para capturar um
novo arquivo para upload com controle de upload de arquivo em cenários de suporte.

func (*TagInputFile) Class 

func (e *TagInputFile) Class(class ...string) (ref *TagInputFile)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputFile) ContentEditable 

func (e *TagInputFile) ContentEditable(editable bool) (ref *TagInputFile)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputFile) CreateElement 

func (e *TagInputFile) CreateElement(tag Tag) (ref *TagInputFile)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputFile) Data 

func (e *TagInputFile) Data(data map[string]string) (ref *TagInputFile)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputFile) Dir 

func (e *TagInputFile) Dir(dir Dir) (ref *TagInputFile)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputFile) Disabled 

func (e *TagInputFile) Disabled(disabled bool) (ref *TagInputFile)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputFile) Draggable 

func (e *TagInputFile) Draggable(draggable Draggable) (ref *TagInputFile)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputFile) EnterKeyHint 

func (e *TagInputFile) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputFile)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputFile) Form 

func (e *TagInputFile) Form(form string) (ref *TagInputFile)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputFile) GetX 

func (e *TagInputFile) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputFile) GetXY 

func (e *TagInputFile) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputFile) GetY 

func (e *TagInputFile) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputFile) Hidden 

func (e *TagInputFile) Hidden() (ref *TagInputFile)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputFile) Id 

func (e *TagInputFile) Id(id string) (ref *TagInputFile)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputFile) InputMode 

func (e *TagInputFile) InputMode(inputMode InputMode) (ref *TagInputFile)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputFile) Is 

func (e *TagInputFile) Is(is string) (ref *TagInputFile)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputFile) ItemDrop 

func (e *TagInputFile) ItemDrop(itemprop string) (ref *TagInputFile)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputFile) ItemId 

func (e *TagInputFile) ItemId(id string) (ref *TagInputFile)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputFile) ItemRef 

func (e *TagInputFile) ItemRef(itemref string) (ref *TagInputFile)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputFile) ItemType 

func (e *TagInputFile) ItemType(itemType string) (ref *TagInputFile)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputFile) Lang 

func (e *TagInputFile) Lang(language Language) (ref *TagInputFile)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputFile) List 

func (e *TagInputFile) List(list string) (ref *TagInputFile)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputFile) Multiple 

func (e *TagInputFile) Multiple(multiple bool) (ref *TagInputFile)

Multiple

English: 

This Boolean attribute indicates that multiple options can be selected in the list. If it is not
specified, then only one option can be selected at a time. When multiple is specified, most
browsers will show a scrolling list box instead of a single line dropdown.

Português: 

Este atributo booleano indica que várias opções podem ser selecionadas na lista. Se não for
especificado, apenas uma opção pode ser selecionada por vez. Quando vários são especificados, a
maioria dos navegadores mostrará uma caixa de listagem de rolagem em vez de uma lista suspensa
de uma única linha.

func (*TagInputFile) Name 

func (e *TagInputFile) Name(name string) (ref *TagInputFile)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputFile) Nonce 

func (e *TagInputFile) Nonce(part ...string) (ref *TagInputFile)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputFile) ReadOnly 

func (e *TagInputFile) ReadOnly(readonly bool) (ref *TagInputFile)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputFile) Required 

func (e *TagInputFile) Required(required bool) (ref *TagInputFile)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputFile) SetX 

func (e *TagInputFile) SetX(x int) (ref *TagInputFile)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputFile) SetXY 

func (e *TagInputFile) SetXY(x, y int) (ref *TagInputFile)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputFile) SetY 

func (e *TagInputFile) SetY(y int) (ref *TagInputFile)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputFile) Slot 

func (e *TagInputFile) Slot(slot string) (ref *TagInputFile)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputFile) Spellcheck 

func (e *TagInputFile) Spellcheck(spell bool) (ref *TagInputFile)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputFile) Style 

func (e *TagInputFile) Style(style string) (ref *TagInputFile)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputFile) TabIndex 

func (e *TagInputFile) TabIndex(index int) (ref *TagInputFile)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputFile) Title 

func (e *TagInputFile) Title(title string) (ref *TagInputFile)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputFile) Translate 

func (e *TagInputFile) Translate(translate Translate) (ref *TagInputFile)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputFile) Type 

func (e *TagInputFile) Type(inputType InputType) (ref *TagInputFile)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputFile) Value 

func (e *TagInputFile) Value(value string) (ref *TagInputFile)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputHidden 

type TagInputHidden struct {
	// contains filtered or unexported fields
}

func (*TagInputHidden) AccessKey 

func (e *TagInputHidden) AccessKey(key string) (ref *TagInputHidden)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputHidden) Append 

func (e *TagInputHidden) Append(append interface{}) (ref *TagInputHidden)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputHidden) AppendById 

func (e *TagInputHidden) AppendById(appendId string) (ref *TagInputHidden)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputHidden) Autocomplete 

func (e *TagInputHidden) Autocomplete(autocomplete Autocomplete) (ref *TagInputHidden)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputHidden) Autofocus 

func (e *TagInputHidden) Autofocus(autofocus bool) (ref *TagInputHidden)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputHidden) Class 

func (e *TagInputHidden) Class(class ...string) (ref *TagInputHidden)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputHidden) ContentEditable 

func (e *TagInputHidden) ContentEditable(editable bool) (ref *TagInputHidden)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputHidden) CreateElement 

func (e *TagInputHidden) CreateElement(tag Tag) (ref *TagInputHidden)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputHidden) Data 

func (e *TagInputHidden) Data(data map[string]string) (ref *TagInputHidden)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputHidden) Dir 

func (e *TagInputHidden) Dir(dir Dir) (ref *TagInputHidden)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputHidden) Disabled 

func (e *TagInputHidden) Disabled(disabled bool) (ref *TagInputHidden)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputHidden) Draggable 

func (e *TagInputHidden) Draggable(draggable Draggable) (ref *TagInputHidden)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputHidden) EnterKeyHint 

func (e *TagInputHidden) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputHidden)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputHidden) Form 

func (e *TagInputHidden) Form(form string) (ref *TagInputHidden)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputHidden) GetX 

func (e *TagInputHidden) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputHidden) GetXY 

func (e *TagInputHidden) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputHidden) GetY 

func (e *TagInputHidden) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputHidden) Hidden 

func (e *TagInputHidden) Hidden() (ref *TagInputHidden)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputHidden) Id 

func (e *TagInputHidden) Id(id string) (ref *TagInputHidden)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputHidden) InputMode 

func (e *TagInputHidden) InputMode(inputMode InputMode) (ref *TagInputHidden)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputHidden) Is 

func (e *TagInputHidden) Is(is string) (ref *TagInputHidden)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputHidden) ItemDrop 

func (e *TagInputHidden) ItemDrop(itemprop string) (ref *TagInputHidden)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputHidden) ItemId 

func (e *TagInputHidden) ItemId(id string) (ref *TagInputHidden)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputHidden) ItemRef 

func (e *TagInputHidden) ItemRef(itemref string) (ref *TagInputHidden)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputHidden) ItemType 

func (e *TagInputHidden) ItemType(itemType string) (ref *TagInputHidden)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputHidden) Lang 

func (e *TagInputHidden) Lang(language Language) (ref *TagInputHidden)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputHidden) List 

func (e *TagInputHidden) List(list string) (ref *TagInputHidden)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputHidden) Min 

func (e *TagInputHidden) Min(min int) (ref *TagInputHidden)

Min

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the most negative
value in the range of permitted values.

If the value entered into the element is less than this, the element fails constraint validation. If the value of the min attribute isn't a number, then the element has no minimum value.

This value must be less than or equal to the value of the max attribute. If the min attribute is present but is not specified or is invalid, no min value is applied. If the min attribute is valid and a non-empty value is less than the minimum allowed by the min attribute, constraint validation will prevent form submission. See Client-side validation for more information.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, data e hora local, número e intervalo, define o valor mais
negativo no intervalo de valores permitidos.

Se o valor inserido no elemento for menor que isso, o elemento falhará na validação de restrição. Se o valor do atributo min não for um número, o elemento não terá valor mínimo.

Esse valor deve ser menor ou igual ao valor do atributo max. Se o atributo min estiver presente, mas não for especificado ou for inválido, nenhum valor min será aplicado. Se o atributo min for válido e um valor não vazio for menor que o mínimo permitido pelo atributo min, a validação de restrição impedirá o envio do formulário. Consulte Validação do lado do cliente para obter mais informações.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputHidden) Name 

func (e *TagInputHidden) Name(name string) (ref *TagInputHidden)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputHidden) Nonce 

func (e *TagInputHidden) Nonce(part ...string) (ref *TagInputHidden)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputHidden) ReadOnly 

func (e *TagInputHidden) ReadOnly(readonly bool) (ref *TagInputHidden)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputHidden) Required 

func (e *TagInputHidden) Required(required bool) (ref *TagInputHidden)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputHidden) SetX 

func (e *TagInputHidden) SetX(x int) (ref *TagInputHidden)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputHidden) SetXY 

func (e *TagInputHidden) SetXY(x, y int) (ref *TagInputHidden)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputHidden) SetY 

func (e *TagInputHidden) SetY(y int) (ref *TagInputHidden)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputHidden) Slot 

func (e *TagInputHidden) Slot(slot string) (ref *TagInputHidden)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputHidden) Spellcheck 

func (e *TagInputHidden) Spellcheck(spell bool) (ref *TagInputHidden)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputHidden) Style 

func (e *TagInputHidden) Style(style string) (ref *TagInputHidden)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputHidden) TabIndex 

func (e *TagInputHidden) TabIndex(index int) (ref *TagInputHidden)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputHidden) Title 

func (e *TagInputHidden) Title(title string) (ref *TagInputHidden)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputHidden) Translate 

func (e *TagInputHidden) Translate(translate Translate) (ref *TagInputHidden)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputHidden) Type 

func (e *TagInputHidden) Type(inputType InputType) (ref *TagInputHidden)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputHidden) Value 

func (e *TagInputHidden) Value(value string) (ref *TagInputHidden)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputImage 

type TagInputImage struct {
	// contains filtered or unexported fields
}

func (*TagInputImage) AccessKey 

func (e *TagInputImage) AccessKey(key string) (ref *TagInputImage)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputImage) Alt 

func (e *TagInputImage) Alt(alt string) (ref *TagInputImage)

Alt

English: 

The alt attribute provides alternative text for the image, displaying the value of the attribute
if the image src is missing or otherwise fails to load.

Português: 

O atributo alt fornece texto alternativo para a imagem, exibindo o valor do atributo se o src da
imagem estiver ausente ou falhar ao carregar.

func (*TagInputImage) Append 

func (e *TagInputImage) Append(append interface{}) (ref *TagInputImage)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputImage) AppendById 

func (e *TagInputImage) AppendById(appendId string) (ref *TagInputImage)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputImage) Autocomplete 

func (e *TagInputImage) Autocomplete(autocomplete Autocomplete) (ref *TagInputImage)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputImage) Autofocus 

func (e *TagInputImage) Autofocus(autofocus bool) (ref *TagInputImage)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputImage) Class 

func (e *TagInputImage) Class(class ...string) (ref *TagInputImage)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputImage) ContentEditable 

func (e *TagInputImage) ContentEditable(editable bool) (ref *TagInputImage)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputImage) CreateElement 

func (e *TagInputImage) CreateElement(tag Tag) (ref *TagInputImage)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputImage) Data 

func (e *TagInputImage) Data(data map[string]string) (ref *TagInputImage)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputImage) Dir 

func (e *TagInputImage) Dir(dir Dir) (ref *TagInputImage)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputImage) Disabled 

func (e *TagInputImage) Disabled(disabled bool) (ref *TagInputImage)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputImage) Draggable 

func (e *TagInputImage) Draggable(draggable Draggable) (ref *TagInputImage)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputImage) EnterKeyHint 

func (e *TagInputImage) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputImage)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputImage) Form 

func (e *TagInputImage) Form(form string) (ref *TagInputImage)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputImage) FormAction 

func (e *TagInputImage) FormAction(action string) (ref *TagInputImage)

FormAction

English: 

A string indicating the URL to which to submit the data. This takes precedence over the action
attribute on the <form> element that owns the <input>.

This attribute is also available on <input type="image"> and <button> elements.

Português: 

Uma string indicando o URL para o qual enviar os dados. Isso tem precedência sobre o atributo
action no elemento <form> que possui o <input>.

Este atributo também está disponível nos elementos <input type="image"> e <button>.

func (*TagInputImage) FormEncType 

func (e *TagInputImage) FormEncType(formenctype FormEncType) (ref *TagInputImage)

FormEncType

English: 

If the button is a submit button (it's inside/associated with a <form> and doesn't have
type="button"), specifies how to encode the form data that is submitted. Possible values:

 Input:
   formenctype: specifies how to encode the form data

     application/x-www-form-urlencoded: The default if the attribute is not used.
     multipart/form-data: Use to submit <input> elements with their type attributes set to file.
     text/plain: Specified as a debugging aid; shouldn't be used for real form submission.

 Note:
   * If this attribute is specified, it overrides the enctype attribute of the button's form
     owner.

Português: 

Se o botão for um botão de envio (está associado a um <form> e não possui type="button"),
especifica como codificar os dados do formulário que são enviados. Valores possíveis:

 Entrada:
   formenctype: especifica como codificar os dados do formulário

     KFormEncTypeApplication: O padrão se o atributo não for usado.
     KFormEncTypeMultiPart: Use para enviar elementos <input> com seus atributos de tipo definidos
       para arquivo.
     KFormEncTypeText: Especificado como auxiliar de depuração; não deve ser usado para envio de
       formulário real.

 Note:
   * Se este atributo for especificado, ele substituirá o atributo enctype do proprietário do
     formulário do botão.

func (*TagInputImage) FormMethod 

func (e *TagInputImage) FormMethod(method FormMethod) (ref *TagInputImage)

FormMethod

English: 

If the button is a submit button (it's inside/associated with a <form> and doesn't have
type="button"), this attribute specifies the HTTP method used to submit the form.

 Input:
   method: specifies the HTTP method used to submit
     KFormMethodPost: The data from the form are included in the body of the HTTP request when
       sent to the server. Use when the form contains information that shouldn't be public, like
       login credentials.
     KFormMethodGet: The form data are appended to the form's action URL, with a ? as a separator,
       and the resulting URL is sent to the server. Use this method when the form has no side
       effects, like search forms.

 Note:
   * If specified, this attribute overrides the method attribute of the button's form owner.

Português: 

Se o botão for um botão de envio (está associado a um <form> e não possui type="button"),
este atributo especifica o método HTTP usado para enviar o formulário.

 Input:
   method: especifica o método HTTP usado para enviar
     KFormMethodPost: Os dados do formulário são incluídos no corpo da solicitação HTTP quando
       enviados ao servidor. Use quando o formulário contém informações que não devem ser
       públicas, como credenciais de login.
     KFormMethodGet: Os dados do formulário são anexados à URL de ação do formulário, com um ?
       como separador e a URL resultante é enviada ao servidor. Use este método quando o
       formulário não tiver efeitos colaterais, como formulários de pesquisa.

 Nota:
   * Se especificado, este atributo substitui o atributo method do proprietário do formulário do
     botão.

func (*TagInputImage) FormTarget 

func (e *TagInputImage) FormTarget(formtarget Target) (ref *TagInputImage)

FormTarget

English: 

If the button is a submit button, this attribute is an author-defined name or standardized,
underscore-prefixed keyword indicating where to display the response from submitting the form.

This is the name of, or keyword for, a browsing context (a tab, window, or <iframe>). If this attribute is specified, it overrides the target attribute of the button's form owner. The following keywords have special meanings: 

KTargetSelf: the current browsing context; (Default)
KTargetBlank: usually a new tab, but users can configure browsers to open a new window instead;
KTargetParent: the parent browsing context of the current one. If no parent, behaves as _self;
KTargetTop: the topmost browsing context (the "highest" context that's an ancestor of the current
  one). If no ancestors, behaves as _self.

Português: 

Se o botão for um botão de envio, esse atributo será um nome definido pelo autor ou uma
palavra-chave padronizada com prefixo de sublinhado indicando onde exibir a resposta do envio do
formulário.

Este é o nome ou a palavra-chave de um contexto de navegação (uma guia, janela ou <iframe>). Se este atributo for especificado, ele substituirá o atributo de destino do proprietário do formulário do botão. As seguintes palavras-chave têm significados especiais: 

KTargetSelf: o contexto de navegação atual; (padrão)
KTargetBlank: geralmente uma nova guia, mas os usuários podem configurar os navegadores para
  abrir uma nova janela;
KTargetParent: o contexto de navegação pai do atual. Se nenhum pai, se comporta como _self;
KTargetTop: o contexto de navegação mais alto (o contexto "mais alto" que é um ancestral do
  atual). Se não houver ancestrais, se comporta como _self.

func (*TagInputImage) FormValidate 

func (e *TagInputImage) FormValidate(validate bool) (ref *TagInputImage)

FormValidate

English: 

If the button is a submit button, this Boolean attribute specifies that the form is not to be
validated when it is submitted.

If this attribute is specified, it overrides the novalidate attribute of the button's form owner.

Português: 

Se o botão for um botão de envio, este atributo booleano especifica que o formulário não deve ser
validado quando for enviado.

Se este atributo for especificado, ele substituirá o atributo novalidate do proprietário do formulário do botão.

func (*TagInputImage) GetX 

func (e *TagInputImage) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputImage) GetXY 

func (e *TagInputImage) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputImage) GetY 

func (e *TagInputImage) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputImage) Height 

func (e *TagInputImage) Height(height int) (ref *TagInputImage)

Height

English: 

The height is the height of the image file to display to represent the graphical submit button.

Português: 

A altura é a altura do arquivo de imagem a ser exibido para representar o botão de envio gráfico.

func (*TagInputImage) Hidden 

func (e *TagInputImage) Hidden() (ref *TagInputImage)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputImage) Id 

func (e *TagInputImage) Id(id string) (ref *TagInputImage)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputImage) InputMode 

func (e *TagInputImage) InputMode(inputMode InputMode) (ref *TagInputImage)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputImage) Is 

func (e *TagInputImage) Is(is string) (ref *TagInputImage)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputImage) ItemDrop 

func (e *TagInputImage) ItemDrop(itemprop string) (ref *TagInputImage)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputImage) ItemId 

func (e *TagInputImage) ItemId(id string) (ref *TagInputImage)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputImage) ItemRef 

func (e *TagInputImage) ItemRef(itemref string) (ref *TagInputImage)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputImage) ItemType 

func (e *TagInputImage) ItemType(itemType string) (ref *TagInputImage)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputImage) Lang 

func (e *TagInputImage) Lang(language Language) (ref *TagInputImage)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputImage) List 

func (e *TagInputImage) List(list string) (ref *TagInputImage)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputImage) Name 

func (e *TagInputImage) Name(name string) (ref *TagInputImage)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputImage) Nonce 

func (e *TagInputImage) Nonce(part ...string) (ref *TagInputImage)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputImage) ReadOnly 

func (e *TagInputImage) ReadOnly(readonly bool) (ref *TagInputImage)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputImage) Required 

func (e *TagInputImage) Required(required bool) (ref *TagInputImage)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputImage) SetX 

func (e *TagInputImage) SetX(x int) (ref *TagInputImage)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputImage) SetXY 

func (e *TagInputImage) SetXY(x, y int) (ref *TagInputImage)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputImage) SetY 

func (e *TagInputImage) SetY(y int) (ref *TagInputImage)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputImage) Slot 

func (e *TagInputImage) Slot(slot string) (ref *TagInputImage)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputImage) Spellcheck 

func (e *TagInputImage) Spellcheck(spell bool) (ref *TagInputImage)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputImage) Src 

func (e *TagInputImage) Src(src string) (ref *TagInputImage)

Src

English: 

Valid for the image input button only, the src is string specifying the URL of the image file to
display to represent the graphical submit button.

Português: 

Válido apenas para o botão de entrada de imagem, o src é uma string que especifica a URL do
arquivo de imagem a ser exibido para representar o botão de envio gráfico.

func (*TagInputImage) Style 

func (e *TagInputImage) Style(style string) (ref *TagInputImage)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputImage) TabIndex 

func (e *TagInputImage) TabIndex(index int) (ref *TagInputImage)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputImage) Title 

func (e *TagInputImage) Title(title string) (ref *TagInputImage)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputImage) Translate 

func (e *TagInputImage) Translate(translate Translate) (ref *TagInputImage)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputImage) Type 

func (e *TagInputImage) Type(inputType InputType) (ref *TagInputImage)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputImage) Value 

func (e *TagInputImage) Value(value string) (ref *TagInputImage)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

func (*TagInputImage) Width 

func (e *TagInputImage) Width(width int) (ref *TagInputImage)

Width

English: 

Valid for the image input button only, the width is the width of the image file to display to
represent the graphical submit button. See the image input type.

Português: 

Válido apenas para o botão de entrada de imagem, a largura é a largura do arquivo de imagem a
ser exibido para representar o botão de envio gráfico. Consulte o tipo de entrada de imagem.

type TagInputMonth 

type TagInputMonth struct {
	// contains filtered or unexported fields
}

func (*TagInputMonth) AccessKey 

func (e *TagInputMonth) AccessKey(key string) (ref *TagInputMonth)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputMonth) Append 

func (e *TagInputMonth) Append(append interface{}) (ref *TagInputMonth)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputMonth) AppendById 

func (e *TagInputMonth) AppendById(appendId string) (ref *TagInputMonth)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputMonth) Autocomplete 

func (e *TagInputMonth) Autocomplete(autocomplete Autocomplete) (ref *TagInputMonth)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputMonth) Autofocus 

func (e *TagInputMonth) Autofocus(autofocus bool) (ref *TagInputMonth)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputMonth) Class 

func (e *TagInputMonth) Class(class ...string) (ref *TagInputMonth)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputMonth) ContentEditable 

func (e *TagInputMonth) ContentEditable(editable bool) (ref *TagInputMonth)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputMonth) CreateElement 

func (e *TagInputMonth) CreateElement(tag Tag) (ref *TagInputMonth)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputMonth) Data 

func (e *TagInputMonth) Data(data map[string]string) (ref *TagInputMonth)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputMonth) Dir 

func (e *TagInputMonth) Dir(dir Dir) (ref *TagInputMonth)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputMonth) Disabled 

func (e *TagInputMonth) Disabled(disabled bool) (ref *TagInputMonth)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputMonth) Draggable 

func (e *TagInputMonth) Draggable(draggable Draggable) (ref *TagInputMonth)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputMonth) EnterKeyHint 

func (e *TagInputMonth) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputMonth)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputMonth) Form 

func (e *TagInputMonth) Form(form string) (ref *TagInputMonth)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputMonth) GetX 

func (e *TagInputMonth) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputMonth) GetXY 

func (e *TagInputMonth) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputMonth) GetY 

func (e *TagInputMonth) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputMonth) Hidden 

func (e *TagInputMonth) Hidden() (ref *TagInputMonth)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputMonth) Id 

func (e *TagInputMonth) Id(id string) (ref *TagInputMonth)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputMonth) InputMode 

func (e *TagInputMonth) InputMode(inputMode InputMode) (ref *TagInputMonth)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputMonth) Is 

func (e *TagInputMonth) Is(is string) (ref *TagInputMonth)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputMonth) ItemDrop 

func (e *TagInputMonth) ItemDrop(itemprop string) (ref *TagInputMonth)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputMonth) ItemId 

func (e *TagInputMonth) ItemId(id string) (ref *TagInputMonth)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputMonth) ItemRef 

func (e *TagInputMonth) ItemRef(itemref string) (ref *TagInputMonth)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputMonth) ItemType 

func (e *TagInputMonth) ItemType(itemType string) (ref *TagInputMonth)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputMonth) Lang 

func (e *TagInputMonth) Lang(language Language) (ref *TagInputMonth)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputMonth) List 

func (e *TagInputMonth) List(list string) (ref *TagInputMonth)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputMonth) Max 

func (e *TagInputMonth) Max(max int) (ref *TagInputMonth)

Max

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the greatest
value in the range of permitted values.
If the value entered into the element exceeds this, the element fails constraint validation.
If the value of the max attribute isn't a number, then the element has no maximum value.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, datetime-local, número e intervalo, define o maior valor no
intervalo de valores permitidos. Se o valor inserido no elemento exceder isso, o elemento falhará
na validação de restrição. Se o valor do atributo max não for um número, o elemento não terá
valor máximo.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputMonth) Min 

func (e *TagInputMonth) Min(min int) (ref *TagInputMonth)

Min

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the most negative
value in the range of permitted values.

If the value entered into the element is less than this, the element fails constraint validation. If the value of the min attribute isn't a number, then the element has no minimum value.

This value must be less than or equal to the value of the max attribute. If the min attribute is present but is not specified or is invalid, no min value is applied. If the min attribute is valid and a non-empty value is less than the minimum allowed by the min attribute, constraint validation will prevent form submission. See Client-side validation for more information.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, data e hora local, número e intervalo, define o valor mais
negativo no intervalo de valores permitidos.

Se o valor inserido no elemento for menor que isso, o elemento falhará na validação de restrição. Se o valor do atributo min não for um número, o elemento não terá valor mínimo.

Esse valor deve ser menor ou igual ao valor do atributo max. Se o atributo min estiver presente, mas não for especificado ou for inválido, nenhum valor min será aplicado. Se o atributo min for válido e um valor não vazio for menor que o mínimo permitido pelo atributo min, a validação de restrição impedirá o envio do formulário. Consulte Validação do lado do cliente para obter mais informações.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputMonth) Name 

func (e *TagInputMonth) Name(name string) (ref *TagInputMonth)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputMonth) Nonce 

func (e *TagInputMonth) Nonce(part ...string) (ref *TagInputMonth)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputMonth) ReadOnly 

func (e *TagInputMonth) ReadOnly(readonly bool) (ref *TagInputMonth)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputMonth) Required 

func (e *TagInputMonth) Required(required bool) (ref *TagInputMonth)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputMonth) SetX 

func (e *TagInputMonth) SetX(x int) (ref *TagInputMonth)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputMonth) SetXY 

func (e *TagInputMonth) SetXY(x, y int) (ref *TagInputMonth)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputMonth) SetY 

func (e *TagInputMonth) SetY(y int) (ref *TagInputMonth)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputMonth) Slot 

func (e *TagInputMonth) Slot(slot string) (ref *TagInputMonth)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputMonth) Spellcheck 

func (e *TagInputMonth) Spellcheck(spell bool) (ref *TagInputMonth)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputMonth) Step 

func (e *TagInputMonth) Step(step int) (ref *TagInputMonth)

Step

English: 

Valid for the numeric input types, including number, date/time input types, and range, the step
attribute is a number that specifies the granularity that the value must adhere to.

 If not explicitly included:
   * step defaults to 1 for number and range;
   * For the date/time input types, step is expressed in seconds, with the default step being 60
     seconds. The step scale factor is 1000 (which converts the seconds to milliseconds, as used
     in other algorithms);
   * The value must be a positive number—integer or float—or the special value any, which means
     no stepping is implied, and any value is allowed (barring other constraints, such as min and
     max).

If any is not explicitly set, valid values for the number, date/time input types, and range input types are equal to the basis for stepping — the min value and increments of the step value, up to the max value, if specified.

For example, if you have <input type="number" min="10" step="2">, then any even integer, 10 or greater, is valid. If omitted, <input type="number">, any integer is valid, but floats (like 4.2) are not valid, because step defaults to 1. For 4.2 to be valid, step would have had to be set to any, 0.1, 0.2, or any the min value would have had to be a number ending in .2, such as <input type="number" min="-5.2"> 

Note:
  * When the data entered by the user doesn't adhere to the stepping configuration, the value is
    considered invalid in constraint validation and will match the :invalid pseudoclass.

Português: 

Válido para os tipos de entrada numérica, incluindo número, tipos de entrada de data e hora e
intervalo, o atributo step é um número que especifica a granularidade à qual o valor deve aderir.

 Se não estiver explicitamente incluído:
   * step padroniza para 1 para número e intervalo.
   * Para os tipos de entrada de data e hora, a etapa é expressa em segundos, com a etapa padrão
     sendo 60 segundos. O fator de escala de passo é 1000 (que converte os segundos em
     milissegundos, conforme usado em outros algoritmos).
   * O valor deve ser um número positivo — inteiro ou flutuante — ou o valor especial any, o que
     significa que nenhuma depuração está implícita e qualquer valor é permitido (exceto outras
     restrições, como min e max).

Se algum não for definido explicitamente, os valores válidos para o número, tipos de entrada de data e hora e tipos de entrada de intervalo são iguais à base para a depuração — o valor mínimo e os incrementos do valor da etapa, até o valor máximo, se especificado.

Por exemplo, se você tiver <input type="number" min="10" step="2">, qualquer número inteiro par, 10 ou maior, é válido. Se omitido, <input type="number">, qualquer inteiro é válido, mas floats (como 4.2) não são válidos, porque step é padronizado como 1. Para 4.2 ser válido, step teria que ser definido como any, 0.1 , 0.2 ou qualquer valor mínimo teria que ser um número que terminasse em .2, como <input type="number" min="-5.2"> 

Nota:
  * Quando os dados inseridos pelo usuário não estão de acordo com a configuração de stepping,
    o valor é considerado inválido na validação da restrição e corresponderá à
    :invalid pseudoclass.

func (*TagInputMonth) Style 

func (e *TagInputMonth) Style(style string) (ref *TagInputMonth)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputMonth) TabIndex 

func (e *TagInputMonth) TabIndex(index int) (ref *TagInputMonth)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputMonth) Title 

func (e *TagInputMonth) Title(title string) (ref *TagInputMonth)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputMonth) Translate 

func (e *TagInputMonth) Translate(translate Translate) (ref *TagInputMonth)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputMonth) Type 

func (e *TagInputMonth) Type(inputType InputType) (ref *TagInputMonth)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputMonth) Value 

func (e *TagInputMonth) Value(value string) (ref *TagInputMonth)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputNumber 

type TagInputNumber struct {
	// contains filtered or unexported fields
}

func (*TagInputNumber) AccessKey 

func (e *TagInputNumber) AccessKey(key string) (ref *TagInputNumber)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputNumber) Append 

func (e *TagInputNumber) Append(append interface{}) (ref *TagInputNumber)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputNumber) AppendById 

func (e *TagInputNumber) AppendById(appendId string) (ref *TagInputNumber)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputNumber) Autocomplete 

func (e *TagInputNumber) Autocomplete(autocomplete Autocomplete) (ref *TagInputNumber)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputNumber) Autofocus 

func (e *TagInputNumber) Autofocus(autofocus bool) (ref *TagInputNumber)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputNumber) Class 

func (e *TagInputNumber) Class(class ...string) (ref *TagInputNumber)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputNumber) ContentEditable 

func (e *TagInputNumber) ContentEditable(editable bool) (ref *TagInputNumber)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputNumber) CreateElement 

func (e *TagInputNumber) CreateElement(tag Tag) (ref *TagInputNumber)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputNumber) Data 

func (e *TagInputNumber) Data(data map[string]string) (ref *TagInputNumber)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputNumber) Dir 

func (e *TagInputNumber) Dir(dir Dir) (ref *TagInputNumber)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputNumber) Disabled 

func (e *TagInputNumber) Disabled(disabled bool) (ref *TagInputNumber)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputNumber) Draggable 

func (e *TagInputNumber) Draggable(draggable Draggable) (ref *TagInputNumber)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputNumber) EnterKeyHint 

func (e *TagInputNumber) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputNumber)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputNumber) Form 

func (e *TagInputNumber) Form(form string) (ref *TagInputNumber)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputNumber) GetX 

func (e *TagInputNumber) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputNumber) GetXY 

func (e *TagInputNumber) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputNumber) GetY 

func (e *TagInputNumber) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputNumber) Hidden 

func (e *TagInputNumber) Hidden() (ref *TagInputNumber)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputNumber) Id 

func (e *TagInputNumber) Id(id string) (ref *TagInputNumber)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputNumber) InputMode 

func (e *TagInputNumber) InputMode(inputMode InputMode) (ref *TagInputNumber)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputNumber) Is 

func (e *TagInputNumber) Is(is string) (ref *TagInputNumber)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputNumber) ItemDrop 

func (e *TagInputNumber) ItemDrop(itemprop string) (ref *TagInputNumber)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputNumber) ItemId 

func (e *TagInputNumber) ItemId(id string) (ref *TagInputNumber)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputNumber) ItemRef 

func (e *TagInputNumber) ItemRef(itemref string) (ref *TagInputNumber)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputNumber) ItemType 

func (e *TagInputNumber) ItemType(itemType string) (ref *TagInputNumber)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputNumber) Lang 

func (e *TagInputNumber) Lang(language Language) (ref *TagInputNumber)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputNumber) List 

func (e *TagInputNumber) List(list string) (ref *TagInputNumber)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputNumber) Max 

func (e *TagInputNumber) Max(max int) (ref *TagInputNumber)

Max

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the greatest
value in the range of permitted values.
If the value entered into the element exceeds this, the element fails constraint validation.
If the value of the max attribute isn't a number, then the element has no maximum value.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, datetime-local, número e intervalo, define o maior valor no
intervalo de valores permitidos. Se o valor inserido no elemento exceder isso, o elemento falhará
na validação de restrição. Se o valor do atributo max não for um número, o elemento não terá
valor máximo.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputNumber) Min 

func (e *TagInputNumber) Min(min int) (ref *TagInputNumber)

Min

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the most negative
value in the range of permitted values.

If the value entered into the element is less than this, the element fails constraint validation. If the value of the min attribute isn't a number, then the element has no minimum value.

This value must be less than or equal to the value of the max attribute. If the min attribute is present but is not specified or is invalid, no min value is applied. If the min attribute is valid and a non-empty value is less than the minimum allowed by the min attribute, constraint validation will prevent form submission. See Client-side validation for more information.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, data e hora local, número e intervalo, define o valor mais
negativo no intervalo de valores permitidos.

Se o valor inserido no elemento for menor que isso, o elemento falhará na validação de restrição. Se o valor do atributo min não for um número, o elemento não terá valor mínimo.

Esse valor deve ser menor ou igual ao valor do atributo max. Se o atributo min estiver presente, mas não for especificado ou for inválido, nenhum valor min será aplicado. Se o atributo min for válido e um valor não vazio for menor que o mínimo permitido pelo atributo min, a validação de restrição impedirá o envio do formulário. Consulte Validação do lado do cliente para obter mais informações.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputNumber) Name 

func (e *TagInputNumber) Name(name string) (ref *TagInputNumber)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputNumber) Nonce 

func (e *TagInputNumber) Nonce(part ...string) (ref *TagInputNumber)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputNumber) ReadOnly 

func (e *TagInputNumber) ReadOnly(readonly bool) (ref *TagInputNumber)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputNumber) Required 

func (e *TagInputNumber) Required(required bool) (ref *TagInputNumber)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputNumber) SetX 

func (e *TagInputNumber) SetX(x int) (ref *TagInputNumber)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputNumber) SetXY 

func (e *TagInputNumber) SetXY(x, y int) (ref *TagInputNumber)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputNumber) SetY 

func (e *TagInputNumber) SetY(y int) (ref *TagInputNumber)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputNumber) Slot 

func (e *TagInputNumber) Slot(slot string) (ref *TagInputNumber)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputNumber) Spellcheck 

func (e *TagInputNumber) Spellcheck(spell bool) (ref *TagInputNumber)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputNumber) Step 

func (e *TagInputNumber) Step(step int) (ref *TagInputNumber)

Step

English: 

Valid for the numeric input types, including number, date/time input types, and range, the step
attribute is a number that specifies the granularity that the value must adhere to.

 If not explicitly included:
   * step defaults to 1 for number and range;
   * For the date/time input types, step is expressed in seconds, with the default step being 60
     seconds. The step scale factor is 1000 (which converts the seconds to milliseconds, as used
     in other algorithms);
   * The value must be a positive number—integer or float—or the special value any, which means
     no stepping is implied, and any value is allowed (barring other constraints, such as min and
     max).

If any is not explicitly set, valid values for the number, date/time input types, and range input types are equal to the basis for stepping — the min value and increments of the step value, up to the max value, if specified.

For example, if you have <input type="number" min="10" step="2">, then any even integer, 10 or greater, is valid. If omitted, <input type="number">, any integer is valid, but floats (like 4.2) are not valid, because step defaults to 1. For 4.2 to be valid, step would have had to be set to any, 0.1, 0.2, or any the min value would have had to be a number ending in .2, such as <input type="number" min="-5.2"> 

Note:
  * When the data entered by the user doesn't adhere to the stepping configuration, the value is
    considered invalid in constraint validation and will match the :invalid pseudoclass.

Português: 

Válido para os tipos de entrada numérica, incluindo número, tipos de entrada de data e hora e
intervalo, o atributo step é um número que especifica a granularidade à qual o valor deve aderir.

 Se não estiver explicitamente incluído:
   * step padroniza para 1 para número e intervalo.
   * Para os tipos de entrada de data e hora, a etapa é expressa em segundos, com a etapa padrão
     sendo 60 segundos. O fator de escala de passo é 1000 (que converte os segundos em
     milissegundos, conforme usado em outros algoritmos).
   * O valor deve ser um número positivo — inteiro ou flutuante — ou o valor especial any, o que
     significa que nenhuma depuração está implícita e qualquer valor é permitido (exceto outras
     restrições, como min e max).

Se algum não for definido explicitamente, os valores válidos para o número, tipos de entrada de data e hora e tipos de entrada de intervalo são iguais à base para a depuração — o valor mínimo e os incrementos do valor da etapa, até o valor máximo, se especificado.

Por exemplo, se você tiver <input type="number" min="10" step="2">, qualquer número inteiro par, 10 ou maior, é válido. Se omitido, <input type="number">, qualquer inteiro é válido, mas floats (como 4.2) não são válidos, porque step é padronizado como 1. Para 4.2 ser válido, step teria que ser definido como any, 0.1 , 0.2 ou qualquer valor mínimo teria que ser um número que terminasse em .2, como <input type="number" min="-5.2"> 

Nota:
  * Quando os dados inseridos pelo usuário não estão de acordo com a configuração de stepping,
    o valor é considerado inválido na validação da restrição e corresponderá à
    :invalid pseudoclass.

func (*TagInputNumber) Style 

func (e *TagInputNumber) Style(style string) (ref *TagInputNumber)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputNumber) TabIndex 

func (e *TagInputNumber) TabIndex(index int) (ref *TagInputNumber)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputNumber) Title 

func (e *TagInputNumber) Title(title string) (ref *TagInputNumber)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputNumber) Translate 

func (e *TagInputNumber) Translate(translate Translate) (ref *TagInputNumber)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputNumber) Type 

func (e *TagInputNumber) Type(inputType InputType) (ref *TagInputNumber)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputNumber) Value 

func (e *TagInputNumber) Value(value string) (ref *TagInputNumber)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputPassword 

type TagInputPassword struct {
	// contains filtered or unexported fields
}

func (*TagInputPassword) AccessKey 

func (e *TagInputPassword) AccessKey(key string) (ref *TagInputPassword)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputPassword) Append 

func (e *TagInputPassword) Append(append interface{}) (ref *TagInputPassword)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputPassword) AppendById 

func (e *TagInputPassword) AppendById(appendId string) (ref *TagInputPassword)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputPassword) Autocomplete 

func (e *TagInputPassword) Autocomplete(autocomplete Autocomplete) (ref *TagInputPassword)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputPassword) Autofocus 

func (e *TagInputPassword) Autofocus(autofocus bool) (ref *TagInputPassword)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputPassword) Class 

func (e *TagInputPassword) Class(class ...string) (ref *TagInputPassword)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputPassword) ContentEditable 

func (e *TagInputPassword) ContentEditable(editable bool) (ref *TagInputPassword)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputPassword) CreateElement 

func (e *TagInputPassword) CreateElement(tag Tag) (ref *TagInputPassword)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputPassword) Data 

func (e *TagInputPassword) Data(data map[string]string) (ref *TagInputPassword)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputPassword) Dir 

func (e *TagInputPassword) Dir(dir Dir) (ref *TagInputPassword)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputPassword) Disabled 

func (e *TagInputPassword) Disabled(disabled bool) (ref *TagInputPassword)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputPassword) Draggable 

func (e *TagInputPassword) Draggable(draggable Draggable) (ref *TagInputPassword)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputPassword) EnterKeyHint 

func (e *TagInputPassword) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputPassword)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputPassword) Form 

func (e *TagInputPassword) Form(form string) (ref *TagInputPassword)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputPassword) GetX 

func (e *TagInputPassword) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputPassword) GetXY 

func (e *TagInputPassword) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputPassword) GetY 

func (e *TagInputPassword) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputPassword) Hidden 

func (e *TagInputPassword) Hidden() (ref *TagInputPassword)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputPassword) Id 

func (e *TagInputPassword) Id(id string) (ref *TagInputPassword)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputPassword) InputMode 

func (e *TagInputPassword) InputMode(inputMode InputMode) (ref *TagInputPassword)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputPassword) Is 

func (e *TagInputPassword) Is(is string) (ref *TagInputPassword)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputPassword) ItemDrop 

func (e *TagInputPassword) ItemDrop(itemprop string) (ref *TagInputPassword)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputPassword) ItemId 

func (e *TagInputPassword) ItemId(id string) (ref *TagInputPassword)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputPassword) ItemRef 

func (e *TagInputPassword) ItemRef(itemref string) (ref *TagInputPassword)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputPassword) ItemType 

func (e *TagInputPassword) ItemType(itemType string) (ref *TagInputPassword)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputPassword) Lang 

func (e *TagInputPassword) Lang(language Language) (ref *TagInputPassword)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputPassword) List 

func (e *TagInputPassword) List(list string) (ref *TagInputPassword)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputPassword) MaxLength 

func (e *TagInputPassword) MaxLength(maxlength int) (ref *TagInputPassword)

MaxLength

English: 

Valid for text, search, url, tel, email, and password, it defines the maximum number of characters
(as UTF-16 code units) the user can enter into the field. This must be an integer value 0 or
higher. If no maxlength is specified, or an invalid value is specified, the field has no maximum
length. This value must also be greater than or equal to the value of minlength.

The input will fail constraint validation if the length of the text entered into the field is greater than maxlength UTF-16 code units long. By default, browsers prevent users from entering more characters than allowed by the maxlength attribute.

Português: 

Válido para texto, pesquisa, url, tel, email e senha, define o número máximo de caracteres
(como unidades de código UTF-16) que o usuário pode inserir no campo.

Este deve ser um valor inteiro 0 ou superior. Se nenhum comprimento máximo for especificado ou um valor inválido for especificado, o campo não terá comprimento máximo. Esse valor também deve ser maior ou igual ao valor de minlength.

A entrada falhará na validação de restrição se o comprimento do texto inserido no campo for maior que o comprimento máximo das unidades de código UTF-16. Por padrão, os navegadores impedem que os usuários insiram mais caracteres do que o permitido pelo atributo maxlength.

func (*TagInputPassword) MinLength 

func (e *TagInputPassword) MinLength(minlength int) (ref *TagInputPassword)

MinLength

English: 

Valid for text, search, url, tel, email, and password, it defines the minimum number of
characters (as UTF-16 code units) the user can enter into the entry field.

This must be an non-negative integer value smaller than or equal to the value specified by maxlength. If no minlength is specified, or an invalid value is specified, the input has no minimum length.

The input will fail constraint validation if the length of the text entered into the field is fewer than minlength UTF-16 code units long, preventing form submission.

Português: 

Válido para texto, pesquisa, url, tel, email e senha, define o número mínimo de caracteres
(como unidades de código UTF-16) que o usuário pode inserir no campo de entrada.

Este deve ser um valor inteiro não negativo menor ou igual ao valor especificado por maxlength. Se nenhum comprimento mínimo for especificado ou um valor inválido for especificado, a entrada não terá comprimento mínimo.

A entrada falhará na validação de restrição se o comprimento do texto inserido no campo for inferior a unidades de código UTF-16 de comprimento mínimo, impedindo o envio do formulário.

func (*TagInputPassword) Name 

func (e *TagInputPassword) Name(name string) (ref *TagInputPassword)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputPassword) Nonce 

func (e *TagInputPassword) Nonce(part ...string) (ref *TagInputPassword)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputPassword) Pattern 

func (e *TagInputPassword) Pattern(pattern string) (ref *TagInputPassword)

Pattern

English: 

The pattern attribute, when specified, is a regular expression that the input's value must match
in order for the value to pass constraint validation. It must be a valid JavaScript regular
expression, as used by the RegExp type, and as documented in our guide on regular expressions;
the 'u' flag is specified when compiling the regular expression, so that the pattern is treated
as a sequence of Unicode code points, instead of as ASCII. No forward slashes should be specified
around the pattern text.

If the pattern attribute is present but is not specified or is invalid, no regular expression is applied and this attribute is ignored completely. If the pattern attribute is valid and a non-empty value does not match the pattern, constraint validation will prevent form submission. 

Note:
  * If using the pattern attribute, inform the user about the expected format by including
    explanatory text nearby. You can also include a title attribute to explain what the
    requirements are to match the pattern; most browsers will display this title as a tooltip.
    The visible explanation is required for accessibility. The tooltip is an enhancement.

Português: 

O atributo pattern, quando especificado, é uma expressão regular que o valor da entrada deve
corresponder para que o valor passe na validação de restrição. Deve ser uma expressão regular
JavaScript válida, conforme usada pelo tipo RegExp e conforme documentado em nosso guia sobre
expressões regulares; o sinalizador 'u' é especificado ao compilar a expressão regular, para que
o padrão seja tratado como uma sequência de pontos de código Unicode, em vez de como ASCII.
Nenhuma barra deve ser especificada ao redor do texto do padrão.

Se o atributo pattern estiver presente, mas não for especificado ou for inválido, nenhuma expressão regular será aplicada e esse atributo será completamente ignorado. Se o atributo de padrão for válido e um valor não vazio não corresponder ao padrão, a validação de restrição impedirá o envio do formulário. 

Nota:
  * Se estiver usando o atributo pattern, informe o usuário sobre o formato esperado incluindo
    um texto explicativo próximo. Você também pode incluir um atributo title para explicar quais
    são os requisitos para corresponder ao padrão; a maioria dos navegadores exibirá este título
    como uma dica de ferramenta. A explicação visível é necessária para acessibilidade. A dica
    de ferramenta é um aprimoramento.

func (*TagInputPassword) Placeholder 

func (e *TagInputPassword) Placeholder(placeholder string) (ref *TagInputPassword)

Placeholder

English: 

The placeholder attribute is a string that provides a brief hint to the user as to what kind of
information is expected in the field. It should be a word or short phrase that provides a hint
as to the expected type of data, rather than an explanation or prompt. The text must not include
carriage returns or line feeds. So for example if a field is expected to capture a user's first
name, and its label is "First Name", a suitable placeholder might be "e.g. Mustafa".

 Note:
   * The placeholder attribute is not as semantically useful as other ways to explain your form,
     and can cause unexpected technical issues with your content. See Labels for more information.

Português: 

O atributo placeholder é uma string que fornece uma breve dica ao usuário sobre que tipo de
informação é esperada no campo. Deve ser uma palavra ou frase curta que forneça uma dica sobre o
tipo de dados esperado, em vez de uma explicação ou prompt. O texto não deve incluir retornos de
carro ou feeds de linha. Assim, por exemplo, se espera-se que um campo capture o primeiro nome de
um usuário e seu rótulo for "Nome", um espaço reservado adequado pode ser "por exemplo, Mustafa".

 Nota:
   * O atributo placeholder não é tão semanticamente útil quanto outras formas de explicar seu
     formulário e pode causar problemas técnicos inesperados com seu conteúdo. Consulte Rótulos
     para obter mais informações.

func (*TagInputPassword) ReadOnly 

func (e *TagInputPassword) ReadOnly(readonly bool) (ref *TagInputPassword)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputPassword) Required 

func (e *TagInputPassword) Required(required bool) (ref *TagInputPassword)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputPassword) SetX 

func (e *TagInputPassword) SetX(x int) (ref *TagInputPassword)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputPassword) SetXY 

func (e *TagInputPassword) SetXY(x, y int) (ref *TagInputPassword)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputPassword) SetY 

func (e *TagInputPassword) SetY(y int) (ref *TagInputPassword)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputPassword) Size 

func (e *TagInputPassword) Size(size int) (ref *TagInputPassword)

Size

English: 

If the control is presented as a scrolling list box (e.g. when multiple is specified), this
attribute represents the number of rows in the list that should be visible at one time.
Browsers are not required to present a select element as a scrolled list box. The default value
is 0.

 Note:
   * According to the HTML5 specification, the default value for size should be 1; however, in
     practice, this has been found to break some web sites, and no other browser currently does
     that, so Mozilla has opted to continue to return 0 for the time being with Firefox.

Português: 

Se o controle for apresentado como uma caixa de listagem de rolagem (por exemplo, quando múltiplo
é especificado), esse atributo representa o número de linhas na lista que devem estar visíveis ao
mesmo tempo. Os navegadores não precisam apresentar um elemento de seleção como uma caixa de
listagem rolada. O valor padrão é 0.

 Nota:
   * De acordo com a especificação HTML5, o valor padrão para tamanho deve ser 1; no entanto, na
     prática, descobriu-se que isso quebra alguns sites, e nenhum outro navegador atualmente faz
     isso, então a Mozilla optou por continuar retornando 0 por enquanto com o Firefox.

func (*TagInputPassword) Slot 

func (e *TagInputPassword) Slot(slot string) (ref *TagInputPassword)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputPassword) Spellcheck 

func (e *TagInputPassword) Spellcheck(spell bool) (ref *TagInputPassword)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputPassword) Style 

func (e *TagInputPassword) Style(style string) (ref *TagInputPassword)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputPassword) TabIndex 

func (e *TagInputPassword) TabIndex(index int) (ref *TagInputPassword)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputPassword) Title 

func (e *TagInputPassword) Title(title string) (ref *TagInputPassword)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputPassword) Translate 

func (e *TagInputPassword) Translate(translate Translate) (ref *TagInputPassword)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputPassword) Type 

func (e *TagInputPassword) Type(inputType InputType) (ref *TagInputPassword)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputPassword) Value 

func (e *TagInputPassword) Value(value string) (ref *TagInputPassword)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputRadio 

type TagInputRadio struct {
	// contains filtered or unexported fields
}

func (*TagInputRadio) AccessKey 

func (e *TagInputRadio) AccessKey(key string) (ref *TagInputRadio)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputRadio) Append 

func (e *TagInputRadio) Append(append interface{}) (ref *TagInputRadio)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputRadio) AppendById 

func (e *TagInputRadio) AppendById(appendId string) (ref *TagInputRadio)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputRadio) Autocomplete 

func (e *TagInputRadio) Autocomplete(autocomplete Autocomplete) (ref *TagInputRadio)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputRadio) Autofocus 

func (e *TagInputRadio) Autofocus(autofocus bool) (ref *TagInputRadio)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputRadio) Checked 

func (e *TagInputRadio) Checked(checked bool) (ref *TagInputRadio)

Checked

English: 

Valid for both radio and checkbox types, checked is a Boolean attribute. If present on a radio
type, it indicates that the radio button is the currently selected one in the group of same-named
radio buttons. If present on a checkbox type, it indicates that the checkbox is checked by default
(when the page loads).
It does not indicate whether this checkbox is currently checked: if the checkbox's state is
changed, this content attribute does not reflect the change.
(Only the HTMLInputElement's checked IDL attribute is updated.)

 Note:
   * Unlike other input controls, a checkboxes and radio buttons value are only included in the
     submitted data if they are currently checked. If they are, the name and the value(s) of the
     checked controls are submitted.
     For example, if a checkbox whose name is fruit has a value of cherry, and the checkbox is
     checked, the form data submitted will include fruit=cherry. If the checkbox isn't active,
     it isn't listed in the form data at all. The default value for checkboxes and radio buttons
     is on.

Português: 

Válido para os tipos de rádio e caixa de seleção, marcado é um atributo booleano. Se estiver
presente em um tipo de rádio, indica que o botão de opção é o selecionado atualmente no grupo de
botões de opção com o mesmo nome. Se estiver presente em um tipo de caixa de seleção, indica que
a caixa de seleção está marcada por padrão (quando a página é carregada). Não indica se esta caixa
de seleção está marcada no momento: se o estado da caixa de seleção for alterado, esse atributo
de conteúdo não reflete a alteração.
(Apenas o atributo IDL verificado do HTMLInputElement é atualizado.)

 Nota:
   * Ao contrário de outros controles de entrada, um valor de caixas de seleção e botões de opção
     só são incluídos nos dados enviados se estiverem marcados no momento. Se estiverem, o nome e
     o(s) valor(es) dos controles verificados são enviados.
     Por exemplo, se uma caixa de seleção cujo nome é fruta tiver o valor cereja e a caixa de
     seleção estiver marcada, os dados do formulário enviados incluirão fruta=cereja.
     Se a caixa de seleção não estiver ativa, ela não está listada nos dados do formulário.
     O valor padrão para caixas de seleção e botões de opção é ativado.

func (*TagInputRadio) Class 

func (e *TagInputRadio) Class(class ...string) (ref *TagInputRadio)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputRadio) ContentEditable 

func (e *TagInputRadio) ContentEditable(editable bool) (ref *TagInputRadio)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputRadio) CreateElement 

func (e *TagInputRadio) CreateElement(tag Tag) (ref *TagInputRadio)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputRadio) Data 

func (e *TagInputRadio) Data(data map[string]string) (ref *TagInputRadio)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputRadio) Dir 

func (e *TagInputRadio) Dir(dir Dir) (ref *TagInputRadio)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputRadio) Disabled 

func (e *TagInputRadio) Disabled(disabled bool) (ref *TagInputRadio)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputRadio) Draggable 

func (e *TagInputRadio) Draggable(draggable Draggable) (ref *TagInputRadio)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputRadio) EnterKeyHint 

func (e *TagInputRadio) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputRadio)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputRadio) Form 

func (e *TagInputRadio) Form(form string) (ref *TagInputRadio)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputRadio) GetX 

func (e *TagInputRadio) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputRadio) GetXY 

func (e *TagInputRadio) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputRadio) GetY 

func (e *TagInputRadio) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputRadio) Hidden 

func (e *TagInputRadio) Hidden() (ref *TagInputRadio)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputRadio) Id 

func (e *TagInputRadio) Id(id string) (ref *TagInputRadio)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputRadio) InputMode 

func (e *TagInputRadio) InputMode(inputMode InputMode) (ref *TagInputRadio)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputRadio) Is 

func (e *TagInputRadio) Is(is string) (ref *TagInputRadio)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputRadio) ItemDrop 

func (e *TagInputRadio) ItemDrop(itemprop string) (ref *TagInputRadio)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputRadio) ItemId 

func (e *TagInputRadio) ItemId(id string) (ref *TagInputRadio)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputRadio) ItemRef 

func (e *TagInputRadio) ItemRef(itemref string) (ref *TagInputRadio)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputRadio) ItemType 

func (e *TagInputRadio) ItemType(itemType string) (ref *TagInputRadio)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputRadio) Lang 

func (e *TagInputRadio) Lang(language Language) (ref *TagInputRadio)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputRadio) List 

func (e *TagInputRadio) List(list string) (ref *TagInputRadio)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputRadio) Name 

func (e *TagInputRadio) Name(name string) (ref *TagInputRadio)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputRadio) Nonce 

func (e *TagInputRadio) Nonce(part ...string) (ref *TagInputRadio)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputRadio) ReadOnly 

func (e *TagInputRadio) ReadOnly(readonly bool) (ref *TagInputRadio)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputRadio) Required 

func (e *TagInputRadio) Required(required bool) (ref *TagInputRadio)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputRadio) SetX 

func (e *TagInputRadio) SetX(x int) (ref *TagInputRadio)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputRadio) SetXY 

func (e *TagInputRadio) SetXY(x, y int) (ref *TagInputRadio)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputRadio) SetY 

func (e *TagInputRadio) SetY(y int) (ref *TagInputRadio)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputRadio) Slot 

func (e *TagInputRadio) Slot(slot string) (ref *TagInputRadio)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputRadio) Spellcheck 

func (e *TagInputRadio) Spellcheck(spell bool) (ref *TagInputRadio)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputRadio) Style 

func (e *TagInputRadio) Style(style string) (ref *TagInputRadio)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputRadio) TabIndex 

func (e *TagInputRadio) TabIndex(index int) (ref *TagInputRadio)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputRadio) Title 

func (e *TagInputRadio) Title(title string) (ref *TagInputRadio)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputRadio) Translate 

func (e *TagInputRadio) Translate(translate Translate) (ref *TagInputRadio)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputRadio) Type 

func (e *TagInputRadio) Type(inputType InputType) (ref *TagInputRadio)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputRadio) Value 

func (e *TagInputRadio) Value(value string) (ref *TagInputRadio)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputRange 

type TagInputRange struct {
	// contains filtered or unexported fields
}

func (*TagInputRange) AccessKey 

func (e *TagInputRange) AccessKey(key string) (ref *TagInputRange)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputRange) Append 

func (e *TagInputRange) Append(append interface{}) (ref *TagInputRange)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputRange) AppendById 

func (e *TagInputRange) AppendById(appendId string) (ref *TagInputRange)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputRange) Autocomplete 

func (e *TagInputRange) Autocomplete(autocomplete Autocomplete) (ref *TagInputRange)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputRange) Autofocus 

func (e *TagInputRange) Autofocus(autofocus bool) (ref *TagInputRange)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputRange) Class 

func (e *TagInputRange) Class(class ...string) (ref *TagInputRange)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputRange) ContentEditable 

func (e *TagInputRange) ContentEditable(editable bool) (ref *TagInputRange)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputRange) CreateElement 

func (e *TagInputRange) CreateElement(tag Tag) (ref *TagInputRange)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputRange) Data 

func (e *TagInputRange) Data(data map[string]string) (ref *TagInputRange)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputRange) Dir 

func (e *TagInputRange) Dir(dir Dir) (ref *TagInputRange)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputRange) Disabled 

func (e *TagInputRange) Disabled(disabled bool) (ref *TagInputRange)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputRange) Draggable 

func (e *TagInputRange) Draggable(draggable Draggable) (ref *TagInputRange)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputRange) EnterKeyHint 

func (e *TagInputRange) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputRange)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputRange) Form 

func (e *TagInputRange) Form(form string) (ref *TagInputRange)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputRange) GetX 

func (e *TagInputRange) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputRange) GetXY 

func (e *TagInputRange) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputRange) GetY 

func (e *TagInputRange) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputRange) Hidden 

func (e *TagInputRange) Hidden() (ref *TagInputRange)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputRange) Id 

func (e *TagInputRange) Id(id string) (ref *TagInputRange)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputRange) InputMode 

func (e *TagInputRange) InputMode(inputMode InputMode) (ref *TagInputRange)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputRange) Is 

func (e *TagInputRange) Is(is string) (ref *TagInputRange)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputRange) ItemDrop 

func (e *TagInputRange) ItemDrop(itemprop string) (ref *TagInputRange)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputRange) ItemId 

func (e *TagInputRange) ItemId(id string) (ref *TagInputRange)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputRange) ItemRef 

func (e *TagInputRange) ItemRef(itemref string) (ref *TagInputRange)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputRange) ItemType 

func (e *TagInputRange) ItemType(itemType string) (ref *TagInputRange)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputRange) Lang 

func (e *TagInputRange) Lang(language Language) (ref *TagInputRange)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputRange) List 

func (e *TagInputRange) List(list string) (ref *TagInputRange)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputRange) Max 

func (e *TagInputRange) Max(max int) (ref *TagInputRange)

Max

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the greatest
value in the range of permitted values.
If the value entered into the element exceeds this, the element fails constraint validation.
If the value of the max attribute isn't a number, then the element has no maximum value.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, datetime-local, número e intervalo, define o maior valor no
intervalo de valores permitidos. Se o valor inserido no elemento exceder isso, o elemento falhará
na validação de restrição. Se o valor do atributo max não for um número, o elemento não terá
valor máximo.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputRange) Min 

func (e *TagInputRange) Min(min int) (ref *TagInputRange)

Min

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the most negative
value in the range of permitted values.

If the value entered into the element is less than this, the element fails constraint validation. If the value of the min attribute isn't a number, then the element has no minimum value.

This value must be less than or equal to the value of the max attribute. If the min attribute is present but is not specified or is invalid, no min value is applied. If the min attribute is valid and a non-empty value is less than the minimum allowed by the min attribute, constraint validation will prevent form submission. See Client-side validation for more information.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, data e hora local, número e intervalo, define o valor mais
negativo no intervalo de valores permitidos.

Se o valor inserido no elemento for menor que isso, o elemento falhará na validação de restrição. Se o valor do atributo min não for um número, o elemento não terá valor mínimo.

Esse valor deve ser menor ou igual ao valor do atributo max. Se o atributo min estiver presente, mas não for especificado ou for inválido, nenhum valor min será aplicado. Se o atributo min for válido e um valor não vazio for menor que o mínimo permitido pelo atributo min, a validação de restrição impedirá o envio do formulário. Consulte Validação do lado do cliente para obter mais informações.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputRange) Name 

func (e *TagInputRange) Name(name string) (ref *TagInputRange)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputRange) Nonce 

func (e *TagInputRange) Nonce(part ...string) (ref *TagInputRange)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputRange) ReadOnly 

func (e *TagInputRange) ReadOnly(readonly bool) (ref *TagInputRange)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputRange) Required 

func (e *TagInputRange) Required(required bool) (ref *TagInputRange)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputRange) SetX 

func (e *TagInputRange) SetX(x int) (ref *TagInputRange)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputRange) SetXY 

func (e *TagInputRange) SetXY(x, y int) (ref *TagInputRange)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputRange) SetY 

func (e *TagInputRange) SetY(y int) (ref *TagInputRange)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputRange) Slot 

func (e *TagInputRange) Slot(slot string) (ref *TagInputRange)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputRange) Spellcheck 

func (e *TagInputRange) Spellcheck(spell bool) (ref *TagInputRange)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputRange) Step 

func (e *TagInputRange) Step(step int) (ref *TagInputRange)

Step

English: 

Valid for the numeric input types, including number, date/time input types, and range, the step
attribute is a number that specifies the granularity that the value must adhere to.

 If not explicitly included:
   * step defaults to 1 for number and range;
   * For the date/time input types, step is expressed in seconds, with the default step being 60
     seconds. The step scale factor is 1000 (which converts the seconds to milliseconds, as used
     in other algorithms);
   * The value must be a positive number—integer or float—or the special value any, which means
     no stepping is implied, and any value is allowed (barring other constraints, such as min and
     max).

If any is not explicitly set, valid values for the number, date/time input types, and range input types are equal to the basis for stepping — the min value and increments of the step value, up to the max value, if specified.

For example, if you have <input type="number" min="10" step="2">, then any even integer, 10 or greater, is valid. If omitted, <input type="number">, any integer is valid, but floats (like 4.2) are not valid, because step defaults to 1. For 4.2 to be valid, step would have had to be set to any, 0.1, 0.2, or any the min value would have had to be a number ending in .2, such as <input type="number" min="-5.2"> 

Note:
  * When the data entered by the user doesn't adhere to the stepping configuration, the value is
    considered invalid in constraint validation and will match the :invalid pseudoclass.

Português: 

Válido para os tipos de entrada numérica, incluindo número, tipos de entrada de data e hora e
intervalo, o atributo step é um número que especifica a granularidade à qual o valor deve aderir.

 Se não estiver explicitamente incluído:
   * step padroniza para 1 para número e intervalo.
   * Para os tipos de entrada de data e hora, a etapa é expressa em segundos, com a etapa padrão
     sendo 60 segundos. O fator de escala de passo é 1000 (que converte os segundos em
     milissegundos, conforme usado em outros algoritmos).
   * O valor deve ser um número positivo — inteiro ou flutuante — ou o valor especial any, o que
     significa que nenhuma depuração está implícita e qualquer valor é permitido (exceto outras
     restrições, como min e max).

Se algum não for definido explicitamente, os valores válidos para o número, tipos de entrada de data e hora e tipos de entrada de intervalo são iguais à base para a depuração — o valor mínimo e os incrementos do valor da etapa, até o valor máximo, se especificado.

Por exemplo, se você tiver <input type="number" min="10" step="2">, qualquer número inteiro par, 10 ou maior, é válido. Se omitido, <input type="number">, qualquer inteiro é válido, mas floats (como 4.2) não são válidos, porque step é padronizado como 1. Para 4.2 ser válido, step teria que ser definido como any, 0.1 , 0.2 ou qualquer valor mínimo teria que ser um número que terminasse em .2, como <input type="number" min="-5.2"> 

Nota:
  * Quando os dados inseridos pelo usuário não estão de acordo com a configuração de stepping,
    o valor é considerado inválido na validação da restrição e corresponderá à
    :invalid pseudoclass.

func (*TagInputRange) Style 

func (e *TagInputRange) Style(style string) (ref *TagInputRange)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputRange) TabIndex 

func (e *TagInputRange) TabIndex(index int) (ref *TagInputRange)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputRange) Title 

func (e *TagInputRange) Title(title string) (ref *TagInputRange)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputRange) Translate 

func (e *TagInputRange) Translate(translate Translate) (ref *TagInputRange)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputRange) Type 

func (e *TagInputRange) Type(inputType InputType) (ref *TagInputRange)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputRange) Value 

func (e *TagInputRange) Value(value string) (ref *TagInputRange)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputSearch 

type TagInputSearch struct {
	// contains filtered or unexported fields
}

func (*TagInputSearch) AccessKey 

func (e *TagInputSearch) AccessKey(key string) (ref *TagInputSearch)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputSearch) Append 

func (e *TagInputSearch) Append(append interface{}) (ref *TagInputSearch)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputSearch) AppendById 

func (e *TagInputSearch) AppendById(appendId string) (ref *TagInputSearch)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputSearch) Autocomplete 

func (e *TagInputSearch) Autocomplete(autocomplete Autocomplete) (ref *TagInputSearch)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputSearch) Autofocus 

func (e *TagInputSearch) Autofocus(autofocus bool) (ref *TagInputSearch)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputSearch) Class 

func (e *TagInputSearch) Class(class ...string) (ref *TagInputSearch)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputSearch) ContentEditable 

func (e *TagInputSearch) ContentEditable(editable bool) (ref *TagInputSearch)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputSearch) CreateElement 

func (e *TagInputSearch) CreateElement(tag Tag) (ref *TagInputSearch)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputSearch) Data 

func (e *TagInputSearch) Data(data map[string]string) (ref *TagInputSearch)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputSearch) Dir 

func (e *TagInputSearch) Dir(dir Dir) (ref *TagInputSearch)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputSearch) DirName 

func (e *TagInputSearch) DirName(dirname string) (ref *TagInputSearch)

DirName

English: 

Valid for text and search input types only, the dirname attribute enables the submission of the
directionality of the element. When included, the form control will submit with two name/value
pairs: the first being the name and value, the second being the value of the dirname as the name
with the value of ltr or rtl being set by the browser.

Português: 

Válido apenas para tipos de entrada de texto e pesquisa, o atributo dirname permite o envio da
direcionalidade do elemento. Quando incluído, o controle de formulário será enviado com dois pares
nomevalor: o primeiro sendo o nome e o valor, o segundo sendo o valor do dirname como o nome com o
valor de ltr ou rtl sendo definido pelo navegador.

func (*TagInputSearch) Disabled 

func (e *TagInputSearch) Disabled(disabled bool) (ref *TagInputSearch)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputSearch) Draggable 

func (e *TagInputSearch) Draggable(draggable Draggable) (ref *TagInputSearch)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputSearch) EnterKeyHint 

func (e *TagInputSearch) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputSearch)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputSearch) Form 

func (e *TagInputSearch) Form(form string) (ref *TagInputSearch)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputSearch) GetX 

func (e *TagInputSearch) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputSearch) GetXY 

func (e *TagInputSearch) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputSearch) GetY 

func (e *TagInputSearch) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputSearch) Hidden 

func (e *TagInputSearch) Hidden() (ref *TagInputSearch)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputSearch) Id 

func (e *TagInputSearch) Id(id string) (ref *TagInputSearch)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputSearch) InputMode 

func (e *TagInputSearch) InputMode(inputMode InputMode) (ref *TagInputSearch)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputSearch) Is 

func (e *TagInputSearch) Is(is string) (ref *TagInputSearch)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputSearch) ItemDrop 

func (e *TagInputSearch) ItemDrop(itemprop string) (ref *TagInputSearch)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputSearch) ItemId 

func (e *TagInputSearch) ItemId(id string) (ref *TagInputSearch)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputSearch) ItemRef 

func (e *TagInputSearch) ItemRef(itemref string) (ref *TagInputSearch)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputSearch) ItemType 

func (e *TagInputSearch) ItemType(itemType string) (ref *TagInputSearch)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputSearch) Lang 

func (e *TagInputSearch) Lang(language Language) (ref *TagInputSearch)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputSearch) List 

func (e *TagInputSearch) List(list string) (ref *TagInputSearch)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputSearch) MaxLength 

func (e *TagInputSearch) MaxLength(maxlength int) (ref *TagInputSearch)

MaxLength

English: 

Valid for text, search, url, tel, email, and password, it defines the maximum number of characters
(as UTF-16 code units) the user can enter into the field. This must be an integer value 0 or
higher. If no maxlength is specified, or an invalid value is specified, the field has no maximum
length. This value must also be greater than or equal to the value of minlength.

The input will fail constraint validation if the length of the text entered into the field is greater than maxlength UTF-16 code units long. By default, browsers prevent users from entering more characters than allowed by the maxlength attribute.

Português: 

Válido para texto, pesquisa, url, tel, email e senha, define o número máximo de caracteres
(como unidades de código UTF-16) que o usuário pode inserir no campo.

Este deve ser um valor inteiro 0 ou superior. Se nenhum comprimento máximo for especificado ou um valor inválido for especificado, o campo não terá comprimento máximo. Esse valor também deve ser maior ou igual ao valor de minlength.

A entrada falhará na validação de restrição se o comprimento do texto inserido no campo for maior que o comprimento máximo das unidades de código UTF-16. Por padrão, os navegadores impedem que os usuários insiram mais caracteres do que o permitido pelo atributo maxlength.

func (*TagInputSearch) MinLength 

func (e *TagInputSearch) MinLength(minlength int) (ref *TagInputSearch)

MinLength

English: 

Valid for text, search, url, tel, email, and password, it defines the minimum number of
characters (as UTF-16 code units) the user can enter into the entry field.

This must be an non-negative integer value smaller than or equal to the value specified by maxlength. If no minlength is specified, or an invalid value is specified, the input has no minimum length.

The input will fail constraint validation if the length of the text entered into the field is fewer than minlength UTF-16 code units long, preventing form submission.

Português: 

Válido para texto, pesquisa, url, tel, email e senha, define o número mínimo de caracteres
(como unidades de código UTF-16) que o usuário pode inserir no campo de entrada.

Este deve ser um valor inteiro não negativo menor ou igual ao valor especificado por maxlength. Se nenhum comprimento mínimo for especificado ou um valor inválido for especificado, a entrada não terá comprimento mínimo.

A entrada falhará na validação de restrição se o comprimento do texto inserido no campo for inferior a unidades de código UTF-16 de comprimento mínimo, impedindo o envio do formulário.

func (*TagInputSearch) Name 

func (e *TagInputSearch) Name(name string) (ref *TagInputSearch)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputSearch) Nonce 

func (e *TagInputSearch) Nonce(part ...string) (ref *TagInputSearch)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputSearch) Placeholder 

func (e *TagInputSearch) Placeholder(placeholder string) (ref *TagInputSearch)

Placeholder

English: 

The placeholder attribute is a string that provides a brief hint to the user as to what kind of
information is expected in the field. It should be a word or short phrase that provides a hint
as to the expected type of data, rather than an explanation or prompt. The text must not include
carriage returns or line feeds. So for example if a field is expected to capture a user's first
name, and its label is "First Name", a suitable placeholder might be "e.g. Mustafa".

 Note:
   * The placeholder attribute is not as semantically useful as other ways to explain your form,
     and can cause unexpected technical issues with your content. See Labels for more information.

Português: 

O atributo placeholder é uma string que fornece uma breve dica ao usuário sobre que tipo de
informação é esperada no campo. Deve ser uma palavra ou frase curta que forneça uma dica sobre o
tipo de dados esperado, em vez de uma explicação ou prompt. O texto não deve incluir retornos de
carro ou feeds de linha. Assim, por exemplo, se espera-se que um campo capture o primeiro nome de
um usuário e seu rótulo for "Nome", um espaço reservado adequado pode ser "por exemplo, Mustafa".

 Nota:
   * O atributo placeholder não é tão semanticamente útil quanto outras formas de explicar seu
     formulário e pode causar problemas técnicos inesperados com seu conteúdo. Consulte Rótulos
     para obter mais informações.

func (*TagInputSearch) ReadOnly 

func (e *TagInputSearch) ReadOnly(readonly bool) (ref *TagInputSearch)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputSearch) Required 

func (e *TagInputSearch) Required(required bool) (ref *TagInputSearch)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputSearch) SetX 

func (e *TagInputSearch) SetX(x int) (ref *TagInputSearch)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputSearch) SetXY 

func (e *TagInputSearch) SetXY(x, y int) (ref *TagInputSearch)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputSearch) SetY 

func (e *TagInputSearch) SetY(y int) (ref *TagInputSearch)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputSearch) Slot 

func (e *TagInputSearch) Slot(slot string) (ref *TagInputSearch)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputSearch) Spellcheck 

func (e *TagInputSearch) Spellcheck(spell bool) (ref *TagInputSearch)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputSearch) Style 

func (e *TagInputSearch) Style(style string) (ref *TagInputSearch)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputSearch) TabIndex 

func (e *TagInputSearch) TabIndex(index int) (ref *TagInputSearch)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputSearch) Title 

func (e *TagInputSearch) Title(title string) (ref *TagInputSearch)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputSearch) Translate 

func (e *TagInputSearch) Translate(translate Translate) (ref *TagInputSearch)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputSearch) Type 

func (e *TagInputSearch) Type(inputType InputType) (ref *TagInputSearch)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputSearch) Value 

func (e *TagInputSearch) Value(value string) (ref *TagInputSearch)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputSubmit 

type TagInputSubmit struct {
	// contains filtered or unexported fields
}

func (*TagInputSubmit) AccessKey 

func (e *TagInputSubmit) AccessKey(key string) (ref *TagInputSubmit)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputSubmit) Append 

func (e *TagInputSubmit) Append(append interface{}) (ref *TagInputSubmit)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputSubmit) AppendById 

func (e *TagInputSubmit) AppendById(appendId string) (ref *TagInputSubmit)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputSubmit) Autocomplete 

func (e *TagInputSubmit) Autocomplete(autocomplete Autocomplete) (ref *TagInputSubmit)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputSubmit) Autofocus 

func (e *TagInputSubmit) Autofocus(autofocus bool) (ref *TagInputSubmit)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputSubmit) Class 

func (e *TagInputSubmit) Class(class ...string) (ref *TagInputSubmit)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputSubmit) ContentEditable 

func (e *TagInputSubmit) ContentEditable(editable bool) (ref *TagInputSubmit)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputSubmit) CreateElement 

func (e *TagInputSubmit) CreateElement(tag Tag) (ref *TagInputSubmit)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputSubmit) Data 

func (e *TagInputSubmit) Data(data map[string]string) (ref *TagInputSubmit)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputSubmit) Dir 

func (e *TagInputSubmit) Dir(dir Dir) (ref *TagInputSubmit)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputSubmit) Disabled 

func (e *TagInputSubmit) Disabled(disabled bool) (ref *TagInputSubmit)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputSubmit) Draggable 

func (e *TagInputSubmit) Draggable(draggable Draggable) (ref *TagInputSubmit)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputSubmit) EnterKeyHint 

func (e *TagInputSubmit) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputSubmit)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputSubmit) Form 

func (e *TagInputSubmit) Form(form string) (ref *TagInputSubmit)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputSubmit) FormAction 

func (e *TagInputSubmit) FormAction(action string) (ref *TagInputSubmit)

FormAction

English: 

A string indicating the URL to which to submit the data. This takes precedence over the action
attribute on the <form> element that owns the <input>.

This attribute is also available on <input type="image"> and <button> elements.

Português: 

Uma string indicando o URL para o qual enviar os dados. Isso tem precedência sobre o atributo
action no elemento <form> que possui o <input>.

Este atributo também está disponível nos elementos <input type="image"> e <button>.

func (*TagInputSubmit) FormEncType 

func (e *TagInputSubmit) FormEncType(formenctype FormEncType) (ref *TagInputSubmit)

FormEncType

English: 

If the button is a submit button (it's inside/associated with a <form> and doesn't have
type="button"), specifies how to encode the form data that is submitted. Possible values:

 Input:
   formenctype: specifies how to encode the form data

     application/x-www-form-urlencoded: The default if the attribute is not used.
     multipart/form-data: Use to submit <input> elements with their type attributes set to file.
     text/plain: Specified as a debugging aid; shouldn't be used for real form submission.

 Note:
   * If this attribute is specified, it overrides the enctype attribute of the button's form
     owner.

Português: 

Se o botão for um botão de envio (está associado a um <form> e não possui type="button"),
especifica como codificar os dados do formulário que são enviados. Valores possíveis:

 Entrada:
   formenctype: especifica como codificar os dados do formulário

     KFormEncTypeApplication: O padrão se o atributo não for usado.
     KFormEncTypeMultiPart: Use para enviar elementos <input> com seus atributos de tipo definidos
       para arquivo.
     KFormEncTypeText: Especificado como auxiliar de depuração; não deve ser usado para envio de
       formulário real.

 Note:
   * Se este atributo for especificado, ele substituirá o atributo enctype do proprietário do
     formulário do botão.

func (*TagInputSubmit) FormMethod 

func (e *TagInputSubmit) FormMethod(method FormMethod) (ref *TagInputSubmit)

FormMethod

English: 

If the button is a submit button (it's inside/associated with a <form> and doesn't have
type="button"), this attribute specifies the HTTP method used to submit the form.

 Input:
   method: specifies the HTTP method used to submit
     KFormMethodPost: The data from the form are included in the body of the HTTP request when
       sent to the server. Use when the form contains information that shouldn't be public, like
       login credentials.
     KFormMethodGet: The form data are appended to the form's action URL, with a ? as a separator,
       and the resulting URL is sent to the server. Use this method when the form has no side
       effects, like search forms.

 Note:
   * If specified, this attribute overrides the method attribute of the button's form owner.

Português: 

Se o botão for um botão de envio (está associado a um <form> e não possui type="button"),
este atributo especifica o método HTTP usado para enviar o formulário.

 Input:
   method: especifica o método HTTP usado para enviar
     KFormMethodPost: Os dados do formulário são incluídos no corpo da solicitação HTTP quando
       enviados ao servidor. Use quando o formulário contém informações que não devem ser
       públicas, como credenciais de login.
     KFormMethodGet: Os dados do formulário são anexados à URL de ação do formulário, com um ?
       como separador e a URL resultante é enviada ao servidor. Use este método quando o
       formulário não tiver efeitos colaterais, como formulários de pesquisa.

 Nota:
   * Se especificado, este atributo substitui o atributo method do proprietário do formulário do
     botão.

func (*TagInputSubmit) FormTarget 

func (e *TagInputSubmit) FormTarget(formtarget Target) (ref *TagInputSubmit)

FormTarget

English: 

If the button is a submit button, this attribute is an author-defined name or standardized,
underscore-prefixed keyword indicating where to display the response from submitting the form.

This is the name of, or keyword for, a browsing context (a tab, window, or <iframe>). If this attribute is specified, it overrides the target attribute of the button's form owner. The following keywords have special meanings: 

KTargetSelf: the current browsing context; (Default)
KTargetBlank: usually a new tab, but users can configure browsers to open a new window instead;
KTargetParent: the parent browsing context of the current one. If no parent, behaves as _self;
KTargetTop: the topmost browsing context (the "highest" context that's an ancestor of the current
  one). If no ancestors, behaves as _self.

Português: 

Se o botão for um botão de envio, esse atributo será um nome definido pelo autor ou uma
palavra-chave padronizada com prefixo de sublinhado indicando onde exibir a resposta do envio do
formulário.

Este é o nome ou a palavra-chave de um contexto de navegação (uma guia, janela ou <iframe>). Se este atributo for especificado, ele substituirá o atributo de destino do proprietário do formulário do botão. As seguintes palavras-chave têm significados especiais: 

KTargetSelf: o contexto de navegação atual; (padrão)
KTargetBlank: geralmente uma nova guia, mas os usuários podem configurar os navegadores para
  abrir uma nova janela;
KTargetParent: o contexto de navegação pai do atual. Se nenhum pai, se comporta como _self;
KTargetTop: o contexto de navegação mais alto (o contexto "mais alto" que é um ancestral do
  atual). Se não houver ancestrais, se comporta como _self.

func (*TagInputSubmit) FormValidate 

func (e *TagInputSubmit) FormValidate(validate bool) (ref *TagInputSubmit)

FormValidate

English: 

If the button is a submit button, this Boolean attribute specifies that the form is not to be
validated when it is submitted.

If this attribute is specified, it overrides the novalidate attribute of the button's form owner.

Português: 

Se o botão for um botão de envio, este atributo booleano especifica que o formulário não deve ser
validado quando for enviado.

Se este atributo for especificado, ele substituirá o atributo novalidate do proprietário do formulário do botão.

func (*TagInputSubmit) GetX 

func (e *TagInputSubmit) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputSubmit) GetXY 

func (e *TagInputSubmit) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputSubmit) GetY 

func (e *TagInputSubmit) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputSubmit) Hidden 

func (e *TagInputSubmit) Hidden() (ref *TagInputSubmit)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputSubmit) Id 

func (e *TagInputSubmit) Id(id string) (ref *TagInputSubmit)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputSubmit) InputMode 

func (e *TagInputSubmit) InputMode(inputMode InputMode) (ref *TagInputSubmit)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputSubmit) Is 

func (e *TagInputSubmit) Is(is string) (ref *TagInputSubmit)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputSubmit) ItemDrop 

func (e *TagInputSubmit) ItemDrop(itemprop string) (ref *TagInputSubmit)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputSubmit) ItemId 

func (e *TagInputSubmit) ItemId(id string) (ref *TagInputSubmit)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputSubmit) ItemRef 

func (e *TagInputSubmit) ItemRef(itemref string) (ref *TagInputSubmit)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputSubmit) ItemType 

func (e *TagInputSubmit) ItemType(itemType string) (ref *TagInputSubmit)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputSubmit) Lang 

func (e *TagInputSubmit) Lang(language Language) (ref *TagInputSubmit)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputSubmit) List 

func (e *TagInputSubmit) List(list string) (ref *TagInputSubmit)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputSubmit) Name 

func (e *TagInputSubmit) Name(name string) (ref *TagInputSubmit)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputSubmit) Nonce 

func (e *TagInputSubmit) Nonce(part ...string) (ref *TagInputSubmit)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputSubmit) ReadOnly 

func (e *TagInputSubmit) ReadOnly(readonly bool) (ref *TagInputSubmit)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputSubmit) Required 

func (e *TagInputSubmit) Required(required bool) (ref *TagInputSubmit)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputSubmit) SetX 

func (e *TagInputSubmit) SetX(x int) (ref *TagInputSubmit)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputSubmit) SetXY 

func (e *TagInputSubmit) SetXY(x, y int) (ref *TagInputSubmit)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputSubmit) SetY 

func (e *TagInputSubmit) SetY(y int) (ref *TagInputSubmit)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputSubmit) Slot 

func (e *TagInputSubmit) Slot(slot string) (ref *TagInputSubmit)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputSubmit) Spellcheck 

func (e *TagInputSubmit) Spellcheck(spell bool) (ref *TagInputSubmit)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputSubmit) Style 

func (e *TagInputSubmit) Style(style string) (ref *TagInputSubmit)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputSubmit) TabIndex 

func (e *TagInputSubmit) TabIndex(index int) (ref *TagInputSubmit)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputSubmit) Title 

func (e *TagInputSubmit) Title(title string) (ref *TagInputSubmit)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputSubmit) Translate 

func (e *TagInputSubmit) Translate(translate Translate) (ref *TagInputSubmit)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputSubmit) Type 

func (e *TagInputSubmit) Type(inputType InputType) (ref *TagInputSubmit)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputSubmit) Value 

func (e *TagInputSubmit) Value(value string) (ref *TagInputSubmit)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputTel 

type TagInputTel struct {
	// contains filtered or unexported fields
}

func (*TagInputTel) AccessKey 

func (e *TagInputTel) AccessKey(key string) (ref *TagInputTel)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputTel) Append 

func (e *TagInputTel) Append(append interface{}) (ref *TagInputTel)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputTel) AppendById 

func (e *TagInputTel) AppendById(appendId string) (ref *TagInputTel)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputTel) Autocomplete 

func (e *TagInputTel) Autocomplete(autocomplete Autocomplete) (ref *TagInputTel)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputTel) Autofocus 

func (e *TagInputTel) Autofocus(autofocus bool) (ref *TagInputTel)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputTel) Class 

func (e *TagInputTel) Class(class ...string) (ref *TagInputTel)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputTel) ContentEditable 

func (e *TagInputTel) ContentEditable(editable bool) (ref *TagInputTel)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputTel) CreateElement 

func (e *TagInputTel) CreateElement(tag Tag) (ref *TagInputTel)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputTel) Data 

func (e *TagInputTel) Data(data map[string]string) (ref *TagInputTel)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputTel) Dir 

func (e *TagInputTel) Dir(dir Dir) (ref *TagInputTel)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputTel) Disabled 

func (e *TagInputTel) Disabled(disabled bool) (ref *TagInputTel)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputTel) Draggable 

func (e *TagInputTel) Draggable(draggable Draggable) (ref *TagInputTel)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputTel) EnterKeyHint 

func (e *TagInputTel) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputTel)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputTel) Form 

func (e *TagInputTel) Form(form string) (ref *TagInputTel)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputTel) GetX 

func (e *TagInputTel) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputTel) GetXY 

func (e *TagInputTel) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputTel) GetY 

func (e *TagInputTel) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputTel) Hidden 

func (e *TagInputTel) Hidden() (ref *TagInputTel)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputTel) Id 

func (e *TagInputTel) Id(id string) (ref *TagInputTel)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputTel) InputMode 

func (e *TagInputTel) InputMode(inputMode InputMode) (ref *TagInputTel)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputTel) Is 

func (e *TagInputTel) Is(is string) (ref *TagInputTel)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputTel) ItemDrop 

func (e *TagInputTel) ItemDrop(itemprop string) (ref *TagInputTel)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputTel) ItemId 

func (e *TagInputTel) ItemId(id string) (ref *TagInputTel)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputTel) ItemRef 

func (e *TagInputTel) ItemRef(itemref string) (ref *TagInputTel)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputTel) ItemType 

func (e *TagInputTel) ItemType(itemType string) (ref *TagInputTel)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputTel) Lang 

func (e *TagInputTel) Lang(language Language) (ref *TagInputTel)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputTel) List 

func (e *TagInputTel) List(list string) (ref *TagInputTel)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputTel) Max 

func (e *TagInputTel) Max(max int) (ref *TagInputTel)

Max

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the greatest
value in the range of permitted values.
If the value entered into the element exceeds this, the element fails constraint validation.
If the value of the max attribute isn't a number, then the element has no maximum value.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, datetime-local, número e intervalo, define o maior valor no
intervalo de valores permitidos. Se o valor inserido no elemento exceder isso, o elemento falhará
na validação de restrição. Se o valor do atributo max não for um número, o elemento não terá
valor máximo.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputTel) MaxLength 

func (e *TagInputTel) MaxLength(maxlength int) (ref *TagInputTel)

MaxLength

English: 

Valid for text, search, url, tel, email, and password, it defines the maximum number of characters
(as UTF-16 code units) the user can enter into the field. This must be an integer value 0 or
higher. If no maxlength is specified, or an invalid value is specified, the field has no maximum
length. This value must also be greater than or equal to the value of minlength.

The input will fail constraint validation if the length of the text entered into the field is greater than maxlength UTF-16 code units long. By default, browsers prevent users from entering more characters than allowed by the maxlength attribute.

Português: 

Válido para texto, pesquisa, url, tel, email e senha, define o número máximo de caracteres
(como unidades de código UTF-16) que o usuário pode inserir no campo.

Este deve ser um valor inteiro 0 ou superior. Se nenhum comprimento máximo for especificado ou um valor inválido for especificado, o campo não terá comprimento máximo. Esse valor também deve ser maior ou igual ao valor de minlength.

A entrada falhará na validação de restrição se o comprimento do texto inserido no campo for maior que o comprimento máximo das unidades de código UTF-16. Por padrão, os navegadores impedem que os usuários insiram mais caracteres do que o permitido pelo atributo maxlength.

func (*TagInputTel) Min 

func (e *TagInputTel) Min(min int) (ref *TagInputTel)

Min

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the most negative
value in the range of permitted values.

If the value entered into the element is less than this, the element fails constraint validation. If the value of the min attribute isn't a number, then the element has no minimum value.

This value must be less than or equal to the value of the max attribute. If the min attribute is present but is not specified or is invalid, no min value is applied. If the min attribute is valid and a non-empty value is less than the minimum allowed by the min attribute, constraint validation will prevent form submission. See Client-side validation for more information.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, data e hora local, número e intervalo, define o valor mais
negativo no intervalo de valores permitidos.

Se o valor inserido no elemento for menor que isso, o elemento falhará na validação de restrição. Se o valor do atributo min não for um número, o elemento não terá valor mínimo.

Esse valor deve ser menor ou igual ao valor do atributo max. Se o atributo min estiver presente, mas não for especificado ou for inválido, nenhum valor min será aplicado. Se o atributo min for válido e um valor não vazio for menor que o mínimo permitido pelo atributo min, a validação de restrição impedirá o envio do formulário. Consulte Validação do lado do cliente para obter mais informações.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputTel) MinLength 

func (e *TagInputTel) MinLength(minlength int) (ref *TagInputTel)

MinLength

English: 

Valid for text, search, url, tel, email, and password, it defines the minimum number of
characters (as UTF-16 code units) the user can enter into the entry field.

This must be an non-negative integer value smaller than or equal to the value specified by maxlength. If no minlength is specified, or an invalid value is specified, the input has no minimum length.

The input will fail constraint validation if the length of the text entered into the field is fewer than minlength UTF-16 code units long, preventing form submission.

Português: 

Válido para texto, pesquisa, url, tel, email e senha, define o número mínimo de caracteres
(como unidades de código UTF-16) que o usuário pode inserir no campo de entrada.

Este deve ser um valor inteiro não negativo menor ou igual ao valor especificado por maxlength. Se nenhum comprimento mínimo for especificado ou um valor inválido for especificado, a entrada não terá comprimento mínimo.

A entrada falhará na validação de restrição se o comprimento do texto inserido no campo for inferior a unidades de código UTF-16 de comprimento mínimo, impedindo o envio do formulário.

func (*TagInputTel) Name 

func (e *TagInputTel) Name(name string) (ref *TagInputTel)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputTel) Nonce 

func (e *TagInputTel) Nonce(part ...string) (ref *TagInputTel)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputTel) Pattern 

func (e *TagInputTel) Pattern(pattern string) (ref *TagInputTel)

Pattern

English: 

The pattern attribute, when specified, is a regular expression that the input's value must match
in order for the value to pass constraint validation. It must be a valid JavaScript regular
expression, as used by the RegExp type, and as documented in our guide on regular expressions;
the 'u' flag is specified when compiling the regular expression, so that the pattern is treated
as a sequence of Unicode code points, instead of as ASCII. No forward slashes should be specified
around the pattern text.

If the pattern attribute is present but is not specified or is invalid, no regular expression is applied and this attribute is ignored completely. If the pattern attribute is valid and a non-empty value does not match the pattern, constraint validation will prevent form submission. 

Note:
  * If using the pattern attribute, inform the user about the expected format by including
    explanatory text nearby. You can also include a title attribute to explain what the
    requirements are to match the pattern; most browsers will display this title as a tooltip.
    The visible explanation is required for accessibility. The tooltip is an enhancement.

Português: 

O atributo pattern, quando especificado, é uma expressão regular que o valor da entrada deve
corresponder para que o valor passe na validação de restrição. Deve ser uma expressão regular
JavaScript válida, conforme usada pelo tipo RegExp e conforme documentado em nosso guia sobre
expressões regulares; o sinalizador 'u' é especificado ao compilar a expressão regular, para que
o padrão seja tratado como uma sequência de pontos de código Unicode, em vez de como ASCII.
Nenhuma barra deve ser especificada ao redor do texto do padrão.

Se o atributo pattern estiver presente, mas não for especificado ou for inválido, nenhuma expressão regular será aplicada e esse atributo será completamente ignorado. Se o atributo de padrão for válido e um valor não vazio não corresponder ao padrão, a validação de restrição impedirá o envio do formulário. 

Nota:
  * Se estiver usando o atributo pattern, informe o usuário sobre o formato esperado incluindo
    um texto explicativo próximo. Você também pode incluir um atributo title para explicar quais
    são os requisitos para corresponder ao padrão; a maioria dos navegadores exibirá este título
    como uma dica de ferramenta. A explicação visível é necessária para acessibilidade. A dica
    de ferramenta é um aprimoramento.

func (*TagInputTel) Placeholder 

func (e *TagInputTel) Placeholder(placeholder string) (ref *TagInputTel)

Placeholder

English: 

The placeholder attribute is a string that provides a brief hint to the user as to what kind of
information is expected in the field. It should be a word or short phrase that provides a hint
as to the expected type of data, rather than an explanation or prompt. The text must not include
carriage returns or line feeds. So for example if a field is expected to capture a user's first
name, and its label is "First Name", a suitable placeholder might be "e.g. Mustafa".

 Note:
   * The placeholder attribute is not as semantically useful as other ways to explain your form,
     and can cause unexpected technical issues with your content. See Labels for more information.

Português: 

O atributo placeholder é uma string que fornece uma breve dica ao usuário sobre que tipo de
informação é esperada no campo. Deve ser uma palavra ou frase curta que forneça uma dica sobre o
tipo de dados esperado, em vez de uma explicação ou prompt. O texto não deve incluir retornos de
carro ou feeds de linha. Assim, por exemplo, se espera-se que um campo capture o primeiro nome de
um usuário e seu rótulo for "Nome", um espaço reservado adequado pode ser "por exemplo, Mustafa".

 Nota:
   * O atributo placeholder não é tão semanticamente útil quanto outras formas de explicar seu
     formulário e pode causar problemas técnicos inesperados com seu conteúdo. Consulte Rótulos
     para obter mais informações.

func (*TagInputTel) ReadOnly 

func (e *TagInputTel) ReadOnly(readonly bool) (ref *TagInputTel)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputTel) Required 

func (e *TagInputTel) Required(required bool) (ref *TagInputTel)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputTel) SetX 

func (e *TagInputTel) SetX(x int) (ref *TagInputTel)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputTel) SetXY 

func (e *TagInputTel) SetXY(x, y int) (ref *TagInputTel)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputTel) SetY 

func (e *TagInputTel) SetY(y int) (ref *TagInputTel)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputTel) Size 

func (e *TagInputTel) Size(size int) (ref *TagInputTel)

Size

English: 

If the control is presented as a scrolling list box (e.g. when multiple is specified), this
attribute represents the number of rows in the list that should be visible at one time.
Browsers are not required to present a select element as a scrolled list box. The default value
is 0.

 Note:
   * According to the HTML5 specification, the default value for size should be 1; however, in
     practice, this has been found to break some web sites, and no other browser currently does
     that, so Mozilla has opted to continue to return 0 for the time being with Firefox.

Português: 

Se o controle for apresentado como uma caixa de listagem de rolagem (por exemplo, quando múltiplo
é especificado), esse atributo representa o número de linhas na lista que devem estar visíveis ao
mesmo tempo. Os navegadores não precisam apresentar um elemento de seleção como uma caixa de
listagem rolada. O valor padrão é 0.

 Nota:
   * De acordo com a especificação HTML5, o valor padrão para tamanho deve ser 1; no entanto, na
     prática, descobriu-se que isso quebra alguns sites, e nenhum outro navegador atualmente faz
     isso, então a Mozilla optou por continuar retornando 0 por enquanto com o Firefox.

func (*TagInputTel) Slot 

func (e *TagInputTel) Slot(slot string) (ref *TagInputTel)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputTel) Spellcheck 

func (e *TagInputTel) Spellcheck(spell bool) (ref *TagInputTel)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputTel) Step 

func (e *TagInputTel) Step(step int) (ref *TagInputTel)

Step

English: 

Valid for the numeric input types, including number, date/time input types, and range, the step
attribute is a number that specifies the granularity that the value must adhere to.

 If not explicitly included:
   * step defaults to 1 for number and range;
   * For the date/time input types, step is expressed in seconds, with the default step being 60
     seconds. The step scale factor is 1000 (which converts the seconds to milliseconds, as used
     in other algorithms);
   * The value must be a positive number—integer or float—or the special value any, which means
     no stepping is implied, and any value is allowed (barring other constraints, such as min and
     max).

If any is not explicitly set, valid values for the number, date/time input types, and range input types are equal to the basis for stepping — the min value and increments of the step value, up to the max value, if specified.

For example, if you have <input type="number" min="10" step="2">, then any even integer, 10 or greater, is valid. If omitted, <input type="number">, any integer is valid, but floats (like 4.2) are not valid, because step defaults to 1. For 4.2 to be valid, step would have had to be set to any, 0.1, 0.2, or any the min value would have had to be a number ending in .2, such as <input type="number" min="-5.2"> 

Note:
  * When the data entered by the user doesn't adhere to the stepping configuration, the value is
    considered invalid in constraint validation and will match the :invalid pseudoclass.

Português: 

Válido para os tipos de entrada numérica, incluindo número, tipos de entrada de data e hora e
intervalo, o atributo step é um número que especifica a granularidade à qual o valor deve aderir.

 Se não estiver explicitamente incluído:
   * step padroniza para 1 para número e intervalo.
   * Para os tipos de entrada de data e hora, a etapa é expressa em segundos, com a etapa padrão
     sendo 60 segundos. O fator de escala de passo é 1000 (que converte os segundos em
     milissegundos, conforme usado em outros algoritmos).
   * O valor deve ser um número positivo — inteiro ou flutuante — ou o valor especial any, o que
     significa que nenhuma depuração está implícita e qualquer valor é permitido (exceto outras
     restrições, como min e max).

Se algum não for definido explicitamente, os valores válidos para o número, tipos de entrada de data e hora e tipos de entrada de intervalo são iguais à base para a depuração — o valor mínimo e os incrementos do valor da etapa, até o valor máximo, se especificado.

Por exemplo, se você tiver <input type="number" min="10" step="2">, qualquer número inteiro par, 10 ou maior, é válido. Se omitido, <input type="number">, qualquer inteiro é válido, mas floats (como 4.2) não são válidos, porque step é padronizado como 1. Para 4.2 ser válido, step teria que ser definido como any, 0.1 , 0.2 ou qualquer valor mínimo teria que ser um número que terminasse em .2, como <input type="number" min="-5.2"> 

Nota:
  * Quando os dados inseridos pelo usuário não estão de acordo com a configuração de stepping,
    o valor é considerado inválido na validação da restrição e corresponderá à
    :invalid pseudoclass.

func (*TagInputTel) Style 

func (e *TagInputTel) Style(style string) (ref *TagInputTel)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputTel) TabIndex 

func (e *TagInputTel) TabIndex(index int) (ref *TagInputTel)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputTel) Title 

func (e *TagInputTel) Title(title string) (ref *TagInputTel)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputTel) Translate 

func (e *TagInputTel) Translate(translate Translate) (ref *TagInputTel)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputTel) Type 

func (e *TagInputTel) Type(inputType InputType) (ref *TagInputTel)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputTel) Value 

func (e *TagInputTel) Value(value string) (ref *TagInputTel)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputText 

type TagInputText struct {
	// contains filtered or unexported fields
}

func (*TagInputText) AccessKey 

func (e *TagInputText) AccessKey(key string) (ref *TagInputText)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputText) Append 

func (e *TagInputText) Append(append interface{}) (ref *TagInputText)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputText) AppendById 

func (e *TagInputText) AppendById(appendId string) (ref *TagInputText)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputText) Autocomplete 

func (e *TagInputText) Autocomplete(autocomplete Autocomplete) (ref *TagInputText)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputText) Autofocus 

func (e *TagInputText) Autofocus(autofocus bool) (ref *TagInputText)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputText) Class 

func (e *TagInputText) Class(class ...string) (ref *TagInputText)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputText) ContentEditable 

func (e *TagInputText) ContentEditable(editable bool) (ref *TagInputText)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputText) CreateElement 

func (e *TagInputText) CreateElement(tag Tag) (ref *TagInputText)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputText) Data 

func (e *TagInputText) Data(data map[string]string) (ref *TagInputText)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputText) Dir 

func (e *TagInputText) Dir(dir Dir) (ref *TagInputText)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputText) DirName 

func (e *TagInputText) DirName(dirname string) (ref *TagInputText)

DirName

English: 

Valid for text and search input types only, the dirname attribute enables the submission of the
directionality of the element. When included, the form control will submit with two name/value
pairs: the first being the name and value, the second being the value of the dirname as the name
with the value of ltr or rtl being set by the browser.

Português: 

Válido apenas para tipos de entrada de texto e pesquisa, o atributo dirname permite o envio da
direcionalidade do elemento. Quando incluído, o controle de formulário será enviado com dois pares
nomevalor: o primeiro sendo o nome e o valor, o segundo sendo o valor do dirname como o nome com o
valor de ltr ou rtl sendo definido pelo navegador.

func (*TagInputText) Disabled 

func (e *TagInputText) Disabled(disabled bool) (ref *TagInputText)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputText) Draggable 

func (e *TagInputText) Draggable(draggable Draggable) (ref *TagInputText)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputText) EnterKeyHint 

func (e *TagInputText) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputText)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputText) Form 

func (e *TagInputText) Form(form string) (ref *TagInputText)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputText) GetX 

func (e *TagInputText) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputText) GetXY 

func (e *TagInputText) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputText) GetY 

func (e *TagInputText) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputText) Hidden 

func (e *TagInputText) Hidden() (ref *TagInputText)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputText) Id 

func (e *TagInputText) Id(id string) (ref *TagInputText)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputText) InputMode 

func (e *TagInputText) InputMode(inputMode InputMode) (ref *TagInputText)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputText) Is 

func (e *TagInputText) Is(is string) (ref *TagInputText)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputText) ItemDrop 

func (e *TagInputText) ItemDrop(itemprop string) (ref *TagInputText)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputText) ItemId 

func (e *TagInputText) ItemId(id string) (ref *TagInputText)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputText) ItemRef 

func (e *TagInputText) ItemRef(itemref string) (ref *TagInputText)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputText) ItemType 

func (e *TagInputText) ItemType(itemType string) (ref *TagInputText)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputText) Lang 

func (e *TagInputText) Lang(language Language) (ref *TagInputText)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputText) List 

func (e *TagInputText) List(list string) (ref *TagInputText)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputText) MaxLength 

func (e *TagInputText) MaxLength(maxlength int) (ref *TagInputText)

MaxLength

English: 

Valid for text, search, url, tel, email, and password, it defines the maximum number of characters
(as UTF-16 code units) the user can enter into the field. This must be an integer value 0 or
higher. If no maxlength is specified, or an invalid value is specified, the field has no maximum
length. This value must also be greater than or equal to the value of minlength.

The input will fail constraint validation if the length of the text entered into the field is greater than maxlength UTF-16 code units long. By default, browsers prevent users from entering more characters than allowed by the maxlength attribute.

Português: 

Válido para texto, pesquisa, url, tel, email e senha, define o número máximo de caracteres
(como unidades de código UTF-16) que o usuário pode inserir no campo.

Este deve ser um valor inteiro 0 ou superior. Se nenhum comprimento máximo for especificado ou um valor inválido for especificado, o campo não terá comprimento máximo. Esse valor também deve ser maior ou igual ao valor de minlength.

A entrada falhará na validação de restrição se o comprimento do texto inserido no campo for maior que o comprimento máximo das unidades de código UTF-16. Por padrão, os navegadores impedem que os usuários insiram mais caracteres do que o permitido pelo atributo maxlength.

func (*TagInputText) MinLength 

func (e *TagInputText) MinLength(minlength int) (ref *TagInputText)

MinLength

English: 

Valid for text, search, url, tel, email, and password, it defines the minimum number of
characters (as UTF-16 code units) the user can enter into the entry field.

This must be an non-negative integer value smaller than or equal to the value specified by maxlength. If no minlength is specified, or an invalid value is specified, the input has no minimum length.

The input will fail constraint validation if the length of the text entered into the field is fewer than minlength UTF-16 code units long, preventing form submission.

Português: 

Válido para texto, pesquisa, url, tel, email e senha, define o número mínimo de caracteres
(como unidades de código UTF-16) que o usuário pode inserir no campo de entrada.

Este deve ser um valor inteiro não negativo menor ou igual ao valor especificado por maxlength. Se nenhum comprimento mínimo for especificado ou um valor inválido for especificado, a entrada não terá comprimento mínimo.

A entrada falhará na validação de restrição se o comprimento do texto inserido no campo for inferior a unidades de código UTF-16 de comprimento mínimo, impedindo o envio do formulário.

func (*TagInputText) Name 

func (e *TagInputText) Name(name string) (ref *TagInputText)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputText) Nonce 

func (e *TagInputText) Nonce(part ...string) (ref *TagInputText)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputText) Pattern 

func (e *TagInputText) Pattern(pattern string) (ref *TagInputText)

Pattern

English: 

The pattern attribute, when specified, is a regular expression that the input's value must match
in order for the value to pass constraint validation. It must be a valid JavaScript regular
expression, as used by the RegExp type, and as documented in our guide on regular expressions;
the 'u' flag is specified when compiling the regular expression, so that the pattern is treated
as a sequence of Unicode code points, instead of as ASCII. No forward slashes should be specified
around the pattern text.

If the pattern attribute is present but is not specified or is invalid, no regular expression is applied and this attribute is ignored completely. If the pattern attribute is valid and a non-empty value does not match the pattern, constraint validation will prevent form submission. 

Note:
  * If using the pattern attribute, inform the user about the expected format by including
    explanatory text nearby. You can also include a title attribute to explain what the
    requirements are to match the pattern; most browsers will display this title as a tooltip.
    The visible explanation is required for accessibility. The tooltip is an enhancement.

Português: 

O atributo pattern, quando especificado, é uma expressão regular que o valor da entrada deve
corresponder para que o valor passe na validação de restrição. Deve ser uma expressão regular
JavaScript válida, conforme usada pelo tipo RegExp e conforme documentado em nosso guia sobre
expressões regulares; o sinalizador 'u' é especificado ao compilar a expressão regular, para que
o padrão seja tratado como uma sequência de pontos de código Unicode, em vez de como ASCII.
Nenhuma barra deve ser especificada ao redor do texto do padrão.

Se o atributo pattern estiver presente, mas não for especificado ou for inválido, nenhuma expressão regular será aplicada e esse atributo será completamente ignorado. Se o atributo de padrão for válido e um valor não vazio não corresponder ao padrão, a validação de restrição impedirá o envio do formulário. 

Nota:
  * Se estiver usando o atributo pattern, informe o usuário sobre o formato esperado incluindo
    um texto explicativo próximo. Você também pode incluir um atributo title para explicar quais
    são os requisitos para corresponder ao padrão; a maioria dos navegadores exibirá este título
    como uma dica de ferramenta. A explicação visível é necessária para acessibilidade. A dica
    de ferramenta é um aprimoramento.

func (*TagInputText) Placeholder 

func (e *TagInputText) Placeholder(placeholder string) (ref *TagInputText)

Placeholder

English: 

The placeholder attribute is a string that provides a brief hint to the user as to what kind of
information is expected in the field. It should be a word or short phrase that provides a hint
as to the expected type of data, rather than an explanation or prompt. The text must not include
carriage returns or line feeds. So for example if a field is expected to capture a user's first
name, and its label is "First Name", a suitable placeholder might be "e.g. Mustafa".

 Note:
   * The placeholder attribute is not as semantically useful as other ways to explain your form,
     and can cause unexpected technical issues with your content. See Labels for more information.

Português: 

O atributo placeholder é uma string que fornece uma breve dica ao usuário sobre que tipo de
informação é esperada no campo. Deve ser uma palavra ou frase curta que forneça uma dica sobre o
tipo de dados esperado, em vez de uma explicação ou prompt. O texto não deve incluir retornos de
carro ou feeds de linha. Assim, por exemplo, se espera-se que um campo capture o primeiro nome de
um usuário e seu rótulo for "Nome", um espaço reservado adequado pode ser "por exemplo, Mustafa".

 Nota:
   * O atributo placeholder não é tão semanticamente útil quanto outras formas de explicar seu
     formulário e pode causar problemas técnicos inesperados com seu conteúdo. Consulte Rótulos
     para obter mais informações.

func (*TagInputText) ReadOnly 

func (e *TagInputText) ReadOnly(readonly bool) (ref *TagInputText)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputText) Required 

func (e *TagInputText) Required(required bool) (ref *TagInputText)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputText) SetX 

func (e *TagInputText) SetX(x int) (ref *TagInputText)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputText) SetXY 

func (e *TagInputText) SetXY(x, y int) (ref *TagInputText)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputText) SetY 

func (e *TagInputText) SetY(y int) (ref *TagInputText)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputText) Size 

func (e *TagInputText) Size(size int) (ref *TagInputText)

Size

English: 

If the control is presented as a scrolling list box (e.g. when multiple is specified), this
attribute represents the number of rows in the list that should be visible at one time.
Browsers are not required to present a select element as a scrolled list box. The default value
is 0.

 Note:
   * According to the HTML5 specification, the default value for size should be 1; however, in
     practice, this has been found to break some web sites, and no other browser currently does
     that, so Mozilla has opted to continue to return 0 for the time being with Firefox.

Português: 

Se o controle for apresentado como uma caixa de listagem de rolagem (por exemplo, quando múltiplo
é especificado), esse atributo representa o número de linhas na lista que devem estar visíveis ao
mesmo tempo. Os navegadores não precisam apresentar um elemento de seleção como uma caixa de
listagem rolada. O valor padrão é 0.

 Nota:
   * De acordo com a especificação HTML5, o valor padrão para tamanho deve ser 1; no entanto, na
     prática, descobriu-se que isso quebra alguns sites, e nenhum outro navegador atualmente faz
     isso, então a Mozilla optou por continuar retornando 0 por enquanto com o Firefox.

func (*TagInputText) Slot 

func (e *TagInputText) Slot(slot string) (ref *TagInputText)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputText) Spellcheck 

func (e *TagInputText) Spellcheck(spell bool) (ref *TagInputText)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputText) Style 

func (e *TagInputText) Style(style string) (ref *TagInputText)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputText) TabIndex 

func (e *TagInputText) TabIndex(index int) (ref *TagInputText)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputText) Title 

func (e *TagInputText) Title(title string) (ref *TagInputText)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputText) Translate 

func (e *TagInputText) Translate(translate Translate) (ref *TagInputText)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputText) Type 

func (e *TagInputText) Type(inputType InputType) (ref *TagInputText)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputText) Value 

func (e *TagInputText) Value(value string) (ref *TagInputText)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputTime 

type TagInputTime struct {
	// contains filtered or unexported fields
}

func (*TagInputTime) AccessKey 

func (e *TagInputTime) AccessKey(key string) (ref *TagInputTime)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputTime) Append 

func (e *TagInputTime) Append(append interface{}) (ref *TagInputTime)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputTime) AppendById 

func (e *TagInputTime) AppendById(appendId string) (ref *TagInputTime)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputTime) Autocomplete 

func (e *TagInputTime) Autocomplete(autocomplete Autocomplete) (ref *TagInputTime)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputTime) Autofocus 

func (e *TagInputTime) Autofocus(autofocus bool) (ref *TagInputTime)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputTime) Class 

func (e *TagInputTime) Class(class ...string) (ref *TagInputTime)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputTime) ContentEditable 

func (e *TagInputTime) ContentEditable(editable bool) (ref *TagInputTime)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputTime) CreateElement 

func (e *TagInputTime) CreateElement(tag Tag) (ref *TagInputTime)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputTime) Data 

func (e *TagInputTime) Data(data map[string]string) (ref *TagInputTime)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputTime) Dir 

func (e *TagInputTime) Dir(dir Dir) (ref *TagInputTime)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputTime) Disabled 

func (e *TagInputTime) Disabled(disabled bool) (ref *TagInputTime)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputTime) Draggable 

func (e *TagInputTime) Draggable(draggable Draggable) (ref *TagInputTime)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputTime) EnterKeyHint 

func (e *TagInputTime) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputTime)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputTime) Form 

func (e *TagInputTime) Form(form string) (ref *TagInputTime)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputTime) GetX 

func (e *TagInputTime) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputTime) GetXY 

func (e *TagInputTime) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputTime) GetY 

func (e *TagInputTime) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputTime) Hidden 

func (e *TagInputTime) Hidden() (ref *TagInputTime)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputTime) Id 

func (e *TagInputTime) Id(id string) (ref *TagInputTime)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputTime) InputMode 

func (e *TagInputTime) InputMode(inputMode InputMode) (ref *TagInputTime)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputTime) Is 

func (e *TagInputTime) Is(is string) (ref *TagInputTime)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputTime) ItemDrop 

func (e *TagInputTime) ItemDrop(itemprop string) (ref *TagInputTime)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputTime) ItemId 

func (e *TagInputTime) ItemId(id string) (ref *TagInputTime)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputTime) ItemRef 

func (e *TagInputTime) ItemRef(itemref string) (ref *TagInputTime)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputTime) ItemType 

func (e *TagInputTime) ItemType(itemType string) (ref *TagInputTime)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputTime) Lang 

func (e *TagInputTime) Lang(language Language) (ref *TagInputTime)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputTime) List 

func (e *TagInputTime) List(list string) (ref *TagInputTime)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputTime) Max 

func (e *TagInputTime) Max(max int) (ref *TagInputTime)

Max

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the greatest
value in the range of permitted values.
If the value entered into the element exceeds this, the element fails constraint validation.
If the value of the max attribute isn't a number, then the element has no maximum value.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, datetime-local, número e intervalo, define o maior valor no
intervalo de valores permitidos. Se o valor inserido no elemento exceder isso, o elemento falhará
na validação de restrição. Se o valor do atributo max não for um número, o elemento não terá
valor máximo.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputTime) Min 

func (e *TagInputTime) Min(min int) (ref *TagInputTime)

Min

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the most negative
value in the range of permitted values.

If the value entered into the element is less than this, the element fails constraint validation. If the value of the min attribute isn't a number, then the element has no minimum value.

This value must be less than or equal to the value of the max attribute. If the min attribute is present but is not specified or is invalid, no min value is applied. If the min attribute is valid and a non-empty value is less than the minimum allowed by the min attribute, constraint validation will prevent form submission. See Client-side validation for more information.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, data e hora local, número e intervalo, define o valor mais
negativo no intervalo de valores permitidos.

Se o valor inserido no elemento for menor que isso, o elemento falhará na validação de restrição. Se o valor do atributo min não for um número, o elemento não terá valor mínimo.

Esse valor deve ser menor ou igual ao valor do atributo max. Se o atributo min estiver presente, mas não for especificado ou for inválido, nenhum valor min será aplicado. Se o atributo min for válido e um valor não vazio for menor que o mínimo permitido pelo atributo min, a validação de restrição impedirá o envio do formulário. Consulte Validação do lado do cliente para obter mais informações.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputTime) Name 

func (e *TagInputTime) Name(name string) (ref *TagInputTime)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputTime) Nonce 

func (e *TagInputTime) Nonce(part ...string) (ref *TagInputTime)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputTime) ReadOnly 

func (e *TagInputTime) ReadOnly(readonly bool) (ref *TagInputTime)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputTime) Required 

func (e *TagInputTime) Required(required bool) (ref *TagInputTime)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputTime) SetX 

func (e *TagInputTime) SetX(x int) (ref *TagInputTime)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputTime) SetXY 

func (e *TagInputTime) SetXY(x, y int) (ref *TagInputTime)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputTime) SetY 

func (e *TagInputTime) SetY(y int) (ref *TagInputTime)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputTime) Slot 

func (e *TagInputTime) Slot(slot string) (ref *TagInputTime)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputTime) Spellcheck 

func (e *TagInputTime) Spellcheck(spell bool) (ref *TagInputTime)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputTime) Step 

func (e *TagInputTime) Step(step int) (ref *TagInputTime)

Step

English: 

Valid for the numeric input types, including number, date/time input types, and range, the step
attribute is a number that specifies the granularity that the value must adhere to.

 If not explicitly included:
   * step defaults to 1 for number and range;
   * For the date/time input types, step is expressed in seconds, with the default step being 60
     seconds. The step scale factor is 1000 (which converts the seconds to milliseconds, as used
     in other algorithms);
   * The value must be a positive number—integer or float—or the special value any, which means
     no stepping is implied, and any value is allowed (barring other constraints, such as min and
     max).

If any is not explicitly set, valid values for the number, date/time input types, and range input types are equal to the basis for stepping — the min value and increments of the step value, up to the max value, if specified.

For example, if you have <input type="number" min="10" step="2">, then any even integer, 10 or greater, is valid. If omitted, <input type="number">, any integer is valid, but floats (like 4.2) are not valid, because step defaults to 1. For 4.2 to be valid, step would have had to be set to any, 0.1, 0.2, or any the min value would have had to be a number ending in .2, such as <input type="number" min="-5.2"> 

Note:
  * When the data entered by the user doesn't adhere to the stepping configuration, the value is
    considered invalid in constraint validation and will match the :invalid pseudoclass.

Português: 

Válido para os tipos de entrada numérica, incluindo número, tipos de entrada de data e hora e
intervalo, o atributo step é um número que especifica a granularidade à qual o valor deve aderir.

 Se não estiver explicitamente incluído:
   * step padroniza para 1 para número e intervalo.
   * Para os tipos de entrada de data e hora, a etapa é expressa em segundos, com a etapa padrão
     sendo 60 segundos. O fator de escala de passo é 1000 (que converte os segundos em
     milissegundos, conforme usado em outros algoritmos).
   * O valor deve ser um número positivo — inteiro ou flutuante — ou o valor especial any, o que
     significa que nenhuma depuração está implícita e qualquer valor é permitido (exceto outras
     restrições, como min e max).

Se algum não for definido explicitamente, os valores válidos para o número, tipos de entrada de data e hora e tipos de entrada de intervalo são iguais à base para a depuração — o valor mínimo e os incrementos do valor da etapa, até o valor máximo, se especificado.

Por exemplo, se você tiver <input type="number" min="10" step="2">, qualquer número inteiro par, 10 ou maior, é válido. Se omitido, <input type="number">, qualquer inteiro é válido, mas floats (como 4.2) não são válidos, porque step é padronizado como 1. Para 4.2 ser válido, step teria que ser definido como any, 0.1 , 0.2 ou qualquer valor mínimo teria que ser um número que terminasse em .2, como <input type="number" min="-5.2"> 

Nota:
  * Quando os dados inseridos pelo usuário não estão de acordo com a configuração de stepping,
    o valor é considerado inválido na validação da restrição e corresponderá à
    :invalid pseudoclass.

func (*TagInputTime) Style 

func (e *TagInputTime) Style(style string) (ref *TagInputTime)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputTime) TabIndex 

func (e *TagInputTime) TabIndex(index int) (ref *TagInputTime)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputTime) Title 

func (e *TagInputTime) Title(title string) (ref *TagInputTime)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputTime) Translate 

func (e *TagInputTime) Translate(translate Translate) (ref *TagInputTime)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputTime) Type 

func (e *TagInputTime) Type(inputType InputType) (ref *TagInputTime)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputTime) Value 

func (e *TagInputTime) Value(value string) (ref *TagInputTime)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputUrl 

type TagInputUrl struct {
	// contains filtered or unexported fields
}

func (*TagInputUrl) AccessKey 

func (e *TagInputUrl) AccessKey(key string) (ref *TagInputUrl)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputUrl) Append 

func (e *TagInputUrl) Append(append interface{}) (ref *TagInputUrl)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputUrl) AppendById 

func (e *TagInputUrl) AppendById(appendId string) (ref *TagInputUrl)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputUrl) Autocomplete 

func (e *TagInputUrl) Autocomplete(autocomplete Autocomplete) (ref *TagInputUrl)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputUrl) Autofocus 

func (e *TagInputUrl) Autofocus(autofocus bool) (ref *TagInputUrl)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputUrl) Class 

func (e *TagInputUrl) Class(class ...string) (ref *TagInputUrl)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputUrl) ContentEditable 

func (e *TagInputUrl) ContentEditable(editable bool) (ref *TagInputUrl)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputUrl) CreateElement 

func (e *TagInputUrl) CreateElement(tag Tag) (ref *TagInputUrl)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputUrl) Data 

func (e *TagInputUrl) Data(data map[string]string) (ref *TagInputUrl)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputUrl) Dir 

func (e *TagInputUrl) Dir(dir Dir) (ref *TagInputUrl)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputUrl) Disabled 

func (e *TagInputUrl) Disabled(disabled bool) (ref *TagInputUrl)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputUrl) Draggable 

func (e *TagInputUrl) Draggable(draggable Draggable) (ref *TagInputUrl)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputUrl) EnterKeyHint 

func (e *TagInputUrl) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputUrl)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputUrl) Form 

func (e *TagInputUrl) Form(form string) (ref *TagInputUrl)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputUrl) GetX 

func (e *TagInputUrl) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputUrl) GetXY 

func (e *TagInputUrl) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputUrl) GetY 

func (e *TagInputUrl) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputUrl) Hidden 

func (e *TagInputUrl) Hidden() (ref *TagInputUrl)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputUrl) Id 

func (e *TagInputUrl) Id(id string) (ref *TagInputUrl)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputUrl) InputMode 

func (e *TagInputUrl) InputMode(inputMode InputMode) (ref *TagInputUrl)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputUrl) Is 

func (e *TagInputUrl) Is(is string) (ref *TagInputUrl)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputUrl) ItemDrop 

func (e *TagInputUrl) ItemDrop(itemprop string) (ref *TagInputUrl)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputUrl) ItemId 

func (e *TagInputUrl) ItemId(id string) (ref *TagInputUrl)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputUrl) ItemRef 

func (e *TagInputUrl) ItemRef(itemref string) (ref *TagInputUrl)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputUrl) ItemType 

func (e *TagInputUrl) ItemType(itemType string) (ref *TagInputUrl)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputUrl) Lang 

func (e *TagInputUrl) Lang(language Language) (ref *TagInputUrl)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputUrl) List 

func (e *TagInputUrl) List(list string) (ref *TagInputUrl)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputUrl) MaxLength 

func (e *TagInputUrl) MaxLength(maxlength int) (ref *TagInputUrl)

MaxLength

English: 

Valid for text, search, url, tel, email, and password, it defines the maximum number of characters
(as UTF-16 code units) the user can enter into the field. This must be an integer value 0 or
higher. If no maxlength is specified, or an invalid value is specified, the field has no maximum
length. This value must also be greater than or equal to the value of minlength.

The input will fail constraint validation if the length of the text entered into the field is greater than maxlength UTF-16 code units long. By default, browsers prevent users from entering more characters than allowed by the maxlength attribute.

Português: 

Válido para texto, pesquisa, url, tel, email e senha, define o número máximo de caracteres
(como unidades de código UTF-16) que o usuário pode inserir no campo.

Este deve ser um valor inteiro 0 ou superior. Se nenhum comprimento máximo for especificado ou um valor inválido for especificado, o campo não terá comprimento máximo. Esse valor também deve ser maior ou igual ao valor de minlength.

A entrada falhará na validação de restrição se o comprimento do texto inserido no campo for maior que o comprimento máximo das unidades de código UTF-16. Por padrão, os navegadores impedem que os usuários insiram mais caracteres do que o permitido pelo atributo maxlength.

func (*TagInputUrl) MinLength 

func (e *TagInputUrl) MinLength(minlength int) (ref *TagInputUrl)

MinLength

English: 

Valid for text, search, url, tel, email, and password, it defines the minimum number of
characters (as UTF-16 code units) the user can enter into the entry field.

This must be an non-negative integer value smaller than or equal to the value specified by maxlength. If no minlength is specified, or an invalid value is specified, the input has no minimum length.

The input will fail constraint validation if the length of the text entered into the field is fewer than minlength UTF-16 code units long, preventing form submission.

Português: 

Válido para texto, pesquisa, url, tel, email e senha, define o número mínimo de caracteres
(como unidades de código UTF-16) que o usuário pode inserir no campo de entrada.

Este deve ser um valor inteiro não negativo menor ou igual ao valor especificado por maxlength. Se nenhum comprimento mínimo for especificado ou um valor inválido for especificado, a entrada não terá comprimento mínimo.

A entrada falhará na validação de restrição se o comprimento do texto inserido no campo for inferior a unidades de código UTF-16 de comprimento mínimo, impedindo o envio do formulário.

func (*TagInputUrl) Name 

func (e *TagInputUrl) Name(name string) (ref *TagInputUrl)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputUrl) Nonce 

func (e *TagInputUrl) Nonce(part ...string) (ref *TagInputUrl)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputUrl) Placeholder 

func (e *TagInputUrl) Placeholder(placeholder string) (ref *TagInputUrl)

Placeholder

English: 

The placeholder attribute is a string that provides a brief hint to the user as to what kind of
information is expected in the field. It should be a word or short phrase that provides a hint
as to the expected type of data, rather than an explanation or prompt. The text must not include
carriage returns or line feeds. So for example if a field is expected to capture a user's first
name, and its label is "First Name", a suitable placeholder might be "e.g. Mustafa".

 Note:
   * The placeholder attribute is not as semantically useful as other ways to explain your form,
     and can cause unexpected technical issues with your content. See Labels for more information.

Português: 

O atributo placeholder é uma string que fornece uma breve dica ao usuário sobre que tipo de
informação é esperada no campo. Deve ser uma palavra ou frase curta que forneça uma dica sobre o
tipo de dados esperado, em vez de uma explicação ou prompt. O texto não deve incluir retornos de
carro ou feeds de linha. Assim, por exemplo, se espera-se que um campo capture o primeiro nome de
um usuário e seu rótulo for "Nome", um espaço reservado adequado pode ser "por exemplo, Mustafa".

 Nota:
   * O atributo placeholder não é tão semanticamente útil quanto outras formas de explicar seu
     formulário e pode causar problemas técnicos inesperados com seu conteúdo. Consulte Rótulos
     para obter mais informações.

func (*TagInputUrl) ReadOnly 

func (e *TagInputUrl) ReadOnly(readonly bool) (ref *TagInputUrl)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputUrl) Required 

func (e *TagInputUrl) Required(required bool) (ref *TagInputUrl)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputUrl) SetX 

func (e *TagInputUrl) SetX(x int) (ref *TagInputUrl)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputUrl) SetXY 

func (e *TagInputUrl) SetXY(x, y int) (ref *TagInputUrl)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputUrl) SetY 

func (e *TagInputUrl) SetY(y int) (ref *TagInputUrl)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputUrl) Size 

func (e *TagInputUrl) Size(size int) (ref *TagInputUrl)

Size

English: 

If the control is presented as a scrolling list box (e.g. when multiple is specified), this
attribute represents the number of rows in the list that should be visible at one time.
Browsers are not required to present a select element as a scrolled list box. The default value
is 0.

 Note:
   * According to the HTML5 specification, the default value for size should be 1; however, in
     practice, this has been found to break some web sites, and no other browser currently does
     that, so Mozilla has opted to continue to return 0 for the time being with Firefox.

Português: 

Se o controle for apresentado como uma caixa de listagem de rolagem (por exemplo, quando múltiplo
é especificado), esse atributo representa o número de linhas na lista que devem estar visíveis ao
mesmo tempo. Os navegadores não precisam apresentar um elemento de seleção como uma caixa de
listagem rolada. O valor padrão é 0.

 Nota:
   * De acordo com a especificação HTML5, o valor padrão para tamanho deve ser 1; no entanto, na
     prática, descobriu-se que isso quebra alguns sites, e nenhum outro navegador atualmente faz
     isso, então a Mozilla optou por continuar retornando 0 por enquanto com o Firefox.

func (*TagInputUrl) Slot 

func (e *TagInputUrl) Slot(slot string) (ref *TagInputUrl)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputUrl) Spellcheck 

func (e *TagInputUrl) Spellcheck(spell bool) (ref *TagInputUrl)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputUrl) Style 

func (e *TagInputUrl) Style(style string) (ref *TagInputUrl)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputUrl) TabIndex 

func (e *TagInputUrl) TabIndex(index int) (ref *TagInputUrl)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputUrl) Title 

func (e *TagInputUrl) Title(title string) (ref *TagInputUrl)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputUrl) Translate 

func (e *TagInputUrl) Translate(translate Translate) (ref *TagInputUrl)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputUrl) Type 

func (e *TagInputUrl) Type(inputType InputType) (ref *TagInputUrl)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputUrl) Value 

func (e *TagInputUrl) Value(value string) (ref *TagInputUrl)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputWeek 

type TagInputWeek struct {
	// contains filtered or unexported fields
}

func (*TagInputWeek) AccessKey 

func (e *TagInputWeek) AccessKey(key string) (ref *TagInputWeek)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputWeek) Append 

func (e *TagInputWeek) Append(append interface{}) (ref *TagInputWeek)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputWeek) AppendById 

func (e *TagInputWeek) AppendById(appendId string) (ref *TagInputWeek)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputWeek) Autocomplete 

func (e *TagInputWeek) Autocomplete(autocomplete Autocomplete) (ref *TagInputWeek)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputWeek) Autofocus 

func (e *TagInputWeek) Autofocus(autofocus bool) (ref *TagInputWeek)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputWeek) Class 

func (e *TagInputWeek) Class(class ...string) (ref *TagInputWeek)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputWeek) ContentEditable 

func (e *TagInputWeek) ContentEditable(editable bool) (ref *TagInputWeek)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputWeek) CreateElement 

func (e *TagInputWeek) CreateElement(tag Tag) (ref *TagInputWeek)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputWeek) Data 

func (e *TagInputWeek) Data(data map[string]string) (ref *TagInputWeek)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputWeek) Dir 

func (e *TagInputWeek) Dir(dir Dir) (ref *TagInputWeek)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputWeek) Disabled 

func (e *TagInputWeek) Disabled(disabled bool) (ref *TagInputWeek)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputWeek) Draggable 

func (e *TagInputWeek) Draggable(draggable Draggable) (ref *TagInputWeek)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputWeek) EnterKeyHint 

func (e *TagInputWeek) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputWeek)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputWeek) Form 

func (e *TagInputWeek) Form(form string) (ref *TagInputWeek)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputWeek) GetX 

func (e *TagInputWeek) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputWeek) GetXY 

func (e *TagInputWeek) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputWeek) GetY 

func (e *TagInputWeek) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputWeek) Hidden 

func (e *TagInputWeek) Hidden() (ref *TagInputWeek)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputWeek) Id 

func (e *TagInputWeek) Id(id string) (ref *TagInputWeek)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputWeek) InputMode 

func (e *TagInputWeek) InputMode(inputMode InputMode) (ref *TagInputWeek)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputWeek) Is 

func (e *TagInputWeek) Is(is string) (ref *TagInputWeek)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputWeek) ItemDrop 

func (e *TagInputWeek) ItemDrop(itemprop string) (ref *TagInputWeek)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputWeek) ItemId 

func (e *TagInputWeek) ItemId(id string) (ref *TagInputWeek)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputWeek) ItemRef 

func (e *TagInputWeek) ItemRef(itemref string) (ref *TagInputWeek)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputWeek) ItemType 

func (e *TagInputWeek) ItemType(itemType string) (ref *TagInputWeek)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputWeek) Lang 

func (e *TagInputWeek) Lang(language Language) (ref *TagInputWeek)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputWeek) List 

func (e *TagInputWeek) List(list string) (ref *TagInputWeek)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputWeek) Max 

func (e *TagInputWeek) Max(max int) (ref *TagInputWeek)

Max

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the greatest
value in the range of permitted values.
If the value entered into the element exceeds this, the element fails constraint validation.
If the value of the max attribute isn't a number, then the element has no maximum value.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, datetime-local, número e intervalo, define o maior valor no
intervalo de valores permitidos. Se o valor inserido no elemento exceder isso, o elemento falhará
na validação de restrição. Se o valor do atributo max não for um número, o elemento não terá
valor máximo.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputWeek) Min 

func (e *TagInputWeek) Min(min int) (ref *TagInputWeek)

Min

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the most negative
value in the range of permitted values.

If the value entered into the element is less than this, the element fails constraint validation. If the value of the min attribute isn't a number, then the element has no minimum value.

This value must be less than or equal to the value of the max attribute. If the min attribute is present but is not specified or is invalid, no min value is applied. If the min attribute is valid and a non-empty value is less than the minimum allowed by the min attribute, constraint validation will prevent form submission. See Client-side validation for more information.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, data e hora local, número e intervalo, define o valor mais
negativo no intervalo de valores permitidos.

Se o valor inserido no elemento for menor que isso, o elemento falhará na validação de restrição. Se o valor do atributo min não for um número, o elemento não terá valor mínimo.

Esse valor deve ser menor ou igual ao valor do atributo max. Se o atributo min estiver presente, mas não for especificado ou for inválido, nenhum valor min será aplicado. Se o atributo min for válido e um valor não vazio for menor que o mínimo permitido pelo atributo min, a validação de restrição impedirá o envio do formulário. Consulte Validação do lado do cliente para obter mais informações.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputWeek) Name 

func (e *TagInputWeek) Name(name string) (ref *TagInputWeek)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputWeek) Nonce 

func (e *TagInputWeek) Nonce(part ...string) (ref *TagInputWeek)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputWeek) ReadOnly 

func (e *TagInputWeek) ReadOnly(readonly bool) (ref *TagInputWeek)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputWeek) Required 

func (e *TagInputWeek) Required(required bool) (ref *TagInputWeek)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputWeek) SetX 

func (e *TagInputWeek) SetX(x int) (ref *TagInputWeek)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputWeek) SetXY 

func (e *TagInputWeek) SetXY(x, y int) (ref *TagInputWeek)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputWeek) SetY 

func (e *TagInputWeek) SetY(y int) (ref *TagInputWeek)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputWeek) Slot 

func (e *TagInputWeek) Slot(slot string) (ref *TagInputWeek)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputWeek) Spellcheck 

func (e *TagInputWeek) Spellcheck(spell bool) (ref *TagInputWeek)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputWeek) Step 

func (e *TagInputWeek) Step(step int) (ref *TagInputWeek)

Step

English: 

Valid for the numeric input types, including number, date/time input types, and range, the step
attribute is a number that specifies the granularity that the value must adhere to.

 If not explicitly included:
   * step defaults to 1 for number and range;
   * For the date/time input types, step is expressed in seconds, with the default step being 60
     seconds. The step scale factor is 1000 (which converts the seconds to milliseconds, as used
     in other algorithms);
   * The value must be a positive number—integer or float—or the special value any, which means
     no stepping is implied, and any value is allowed (barring other constraints, such as min and
     max).

If any is not explicitly set, valid values for the number, date/time input types, and range input types are equal to the basis for stepping — the min value and increments of the step value, up to the max value, if specified.

For example, if you have <input type="number" min="10" step="2">, then any even integer, 10 or greater, is valid. If omitted, <input type="number">, any integer is valid, but floats (like 4.2) are not valid, because step defaults to 1. For 4.2 to be valid, step would have had to be set to any, 0.1, 0.2, or any the min value would have had to be a number ending in .2, such as <input type="number" min="-5.2"> 

Note:
  * When the data entered by the user doesn't adhere to the stepping configuration, the value is
    considered invalid in constraint validation and will match the :invalid pseudoclass.

Português: 

Válido para os tipos de entrada numérica, incluindo número, tipos de entrada de data e hora e
intervalo, o atributo step é um número que especifica a granularidade à qual o valor deve aderir.

 Se não estiver explicitamente incluído:
   * step padroniza para 1 para número e intervalo.
   * Para os tipos de entrada de data e hora, a etapa é expressa em segundos, com a etapa padrão
     sendo 60 segundos. O fator de escala de passo é 1000 (que converte os segundos em
     milissegundos, conforme usado em outros algoritmos).
   * O valor deve ser um número positivo — inteiro ou flutuante — ou o valor especial any, o que
     significa que nenhuma depuração está implícita e qualquer valor é permitido (exceto outras
     restrições, como min e max).

Se algum não for definido explicitamente, os valores válidos para o número, tipos de entrada de data e hora e tipos de entrada de intervalo são iguais à base para a depuração — o valor mínimo e os incrementos do valor da etapa, até o valor máximo, se especificado.

Por exemplo, se você tiver <input type="number" min="10" step="2">, qualquer número inteiro par, 10 ou maior, é válido. Se omitido, <input type="number">, qualquer inteiro é válido, mas floats (como 4.2) não são válidos, porque step é padronizado como 1. Para 4.2 ser válido, step teria que ser definido como any, 0.1 , 0.2 ou qualquer valor mínimo teria que ser um número que terminasse em .2, como <input type="number" min="-5.2"> 

Nota:
  * Quando os dados inseridos pelo usuário não estão de acordo com a configuração de stepping,
    o valor é considerado inválido na validação da restrição e corresponderá à
    :invalid pseudoclass.

func (*TagInputWeek) Style 

func (e *TagInputWeek) Style(style string) (ref *TagInputWeek)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputWeek) TabIndex 

func (e *TagInputWeek) TabIndex(index int) (ref *TagInputWeek)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputWeek) Title 

func (e *TagInputWeek) Title(title string) (ref *TagInputWeek)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputWeek) Translate 

func (e *TagInputWeek) Translate(translate Translate) (ref *TagInputWeek)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputWeek) Type 

func (e *TagInputWeek) Type(inputType InputType) (ref *TagInputWeek)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputWeek) Value 

func (e *TagInputWeek) Value(value string) (ref *TagInputWeek)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagLabel 

type TagLabel struct {
	// contains filtered or unexported fields
}

func (*TagLabel) AccessKey 

func (e *TagLabel) AccessKey(key string) (ref *TagLabel)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagLabel) Append 

func (e *TagLabel) Append(append interface{}) (ref *TagLabel)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagLabel) AppendById 

func (e *TagLabel) AppendById(appendId string) (ref *TagLabel)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagLabel) Autofocus 

func (e *TagLabel) Autofocus(autofocus bool) (ref *TagLabel)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagLabel) Class 

func (e *TagLabel) Class(class ...string) (ref *TagLabel)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagLabel) ContentEditable 

func (e *TagLabel) ContentEditable(editable bool) (ref *TagLabel)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagLabel) CreateElement 

func (e *TagLabel) CreateElement(tag Tag) (ref *TagLabel)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagLabel) Data 

func (e *TagLabel) Data(data map[string]string) (ref *TagLabel)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagLabel) Dir 

func (e *TagLabel) Dir(dir Dir) (ref *TagLabel)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagLabel) Draggable 

func (e *TagLabel) Draggable(draggable Draggable) (ref *TagLabel)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagLabel) EnterKeyHint 

func (e *TagLabel) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagLabel)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagLabel) Form 

func (e *TagLabel) Form(form string) (ref *TagLabel)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagLabel) GetX 

func (e *TagLabel) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagLabel) GetXY 

func (e *TagLabel) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagLabel) GetY 

func (e *TagLabel) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagLabel) Hidden 

func (e *TagLabel) Hidden() (ref *TagLabel)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagLabel) Id 

func (e *TagLabel) Id(id string) (ref *TagLabel)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagLabel) InputMode 

func (e *TagLabel) InputMode(inputMode InputMode) (ref *TagLabel)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagLabel) Is 

func (e *TagLabel) Is(is string) (ref *TagLabel)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagLabel) ItemDrop 

func (e *TagLabel) ItemDrop(itemprop string) (ref *TagLabel)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagLabel) ItemId 

func (e *TagLabel) ItemId(id string) (ref *TagLabel)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagLabel) ItemRef 

func (e *TagLabel) ItemRef(itemref string) (ref *TagLabel)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagLabel) ItemType 

func (e *TagLabel) ItemType(itemType string) (ref *TagLabel)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagLabel) Lang 

func (e *TagLabel) Lang(language Language) (ref *TagLabel)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagLabel) Nonce 

func (e *TagLabel) Nonce(part ...string) (ref *TagLabel)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagLabel) SetX 

func (e *TagLabel) SetX(x int) (ref *TagLabel)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagLabel) SetXY 

func (e *TagLabel) SetXY(x, y int) (ref *TagLabel)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagLabel) SetY 

func (e *TagLabel) SetY(y int) (ref *TagLabel)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagLabel) Slot 

func (e *TagLabel) Slot(slot string) (ref *TagLabel)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagLabel) Spellcheck 

func (e *TagLabel) Spellcheck(spell bool) (ref *TagLabel)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagLabel) Style 

func (e *TagLabel) Style(style string) (ref *TagLabel)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagLabel) TabIndex 

func (e *TagLabel) TabIndex(index int) (ref *TagLabel)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagLabel) Title 

func (e *TagLabel) Title(title string) (ref *TagLabel)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagLabel) Translate 

func (e *TagLabel) Translate(translate Translate) (ref *TagLabel)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

type TagLegend 

type TagLegend struct {
	// contains filtered or unexported fields
}

func (*TagLegend) AccessKey 

func (e *TagLegend) AccessKey(key string) (ref *TagLegend)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagLegend) Append 

func (e *TagLegend) Append(append interface{}) (ref *TagLegend)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagLegend) AppendById 

func (e *TagLegend) AppendById(appendId string) (ref *TagLegend)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagLegend) Autofocus 

func (e *TagLegend) Autofocus(autofocus bool) (ref *TagLegend)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagLegend) Class 

func (e *TagLegend) Class(class ...string) (ref *TagLegend)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagLegend) ContentEditable 

func (e *TagLegend) ContentEditable(editable bool) (ref *TagLegend)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagLegend) CreateElement 

func (e *TagLegend) CreateElement(tag Tag) (ref *TagLegend)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagLegend) Data 

func (e *TagLegend) Data(data map[string]string) (ref *TagLegend)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagLegend) Dir 

func (e *TagLegend) Dir(dir Dir) (ref *TagLegend)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagLegend) Draggable 

func (e *TagLegend) Draggable(draggable Draggable) (ref *TagLegend)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagLegend) EnterKeyHint 

func (e *TagLegend) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagLegend)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagLegend) GetX 

func (e *TagLegend) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagLegend) GetXY 

func (e *TagLegend) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagLegend) GetY 

func (e *TagLegend) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagLegend) Hidden 

func (e *TagLegend) Hidden() (ref *TagLegend)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagLegend) Id 

func (e *TagLegend) Id(id string) (ref *TagLegend)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagLegend) InputMode 

func (e *TagLegend) InputMode(inputMode InputMode) (ref *TagLegend)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagLegend) Is 

func (e *TagLegend) Is(is string) (ref *TagLegend)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagLegend) ItemDrop 

func (e *TagLegend) ItemDrop(itemprop string) (ref *TagLegend)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagLegend) ItemId 

func (e *TagLegend) ItemId(id string) (ref *TagLegend)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagLegend) ItemRef 

func (e *TagLegend) ItemRef(itemref string) (ref *TagLegend)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagLegend) ItemType 

func (e *TagLegend) ItemType(itemType string) (ref *TagLegend)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagLegend) Lang 

func (e *TagLegend) Lang(language Language) (ref *TagLegend)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagLegend) Nonce 

func (e *TagLegend) Nonce(part ...string) (ref *TagLegend)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagLegend) SetX 

func (e *TagLegend) SetX(x int) (ref *TagLegend)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagLegend) SetXY 

func (e *TagLegend) SetXY(x, y int) (ref *TagLegend)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagLegend) SetY 

func (e *TagLegend) SetY(y int) (ref *TagLegend)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagLegend) Slot 

func (e *TagLegend) Slot(slot string) (ref *TagLegend)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagLegend) Spellcheck 

func (e *TagLegend) Spellcheck(spell bool) (ref *TagLegend)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagLegend) Style 

func (e *TagLegend) Style(style string) (ref *TagLegend)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagLegend) TabIndex 

func (e *TagLegend) TabIndex(index int) (ref *TagLegend)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagLegend) Title 

func (e *TagLegend) Title(title string) (ref *TagLegend)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagLegend) Translate 

func (e *TagLegend) Translate(translate Translate) (ref *TagLegend)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

type TagMeter 

type TagMeter struct {
	// contains filtered or unexported fields
}

func (*TagMeter) AccessKey 

func (e *TagMeter) AccessKey(key string) (ref *TagMeter)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagMeter) Append 

func (e *TagMeter) Append(append interface{}) (ref *TagMeter)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagMeter) AppendById 

func (e *TagMeter) AppendById(appendId string) (ref *TagMeter)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagMeter) Autofocus 

func (e *TagMeter) Autofocus(autofocus bool) (ref *TagMeter)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagMeter) Class 

func (e *TagMeter) Class(class ...string) (ref *TagMeter)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagMeter) ContentEditable 

func (e *TagMeter) ContentEditable(editable bool) (ref *TagMeter)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagMeter) CreateElement 

func (e *TagMeter) CreateElement(tag Tag) (ref *TagMeter)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagMeter) Data 

func (e *TagMeter) Data(data map[string]string) (ref *TagMeter)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagMeter) Dir 

func (e *TagMeter) Dir(dir Dir) (ref *TagMeter)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagMeter) Draggable 

func (e *TagMeter) Draggable(draggable Draggable) (ref *TagMeter)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagMeter) EnterKeyHint 

func (e *TagMeter) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagMeter)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagMeter) GetX 

func (e *TagMeter) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagMeter) GetXY 

func (e *TagMeter) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagMeter) GetY 

func (e *TagMeter) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagMeter) Hidden 

func (e *TagMeter) Hidden() (ref *TagMeter)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagMeter) High 

func (e *TagMeter) High(value float64) (ref *TagMeter)

High

English: 

The lower numeric bound of the high end of the measured range. This must be less than the maximum
value (max attribute), and it also must be greater than the low value and minimum value (low
attribute and min attribute, respectively), if any are specified. If unspecified, or if greater
than the maximum value, the high value is equal to the maximum value.

Português: 

O limite numérico inferior da extremidade superior do intervalo medido. Isso deve ser menor que o
valor máximo (atributo max) e também deve ser maior que o valor baixo e o valor mínimo (atributo
baixo e atributo min, respectivamente), se algum for especificado. Se não especificado, ou se for
maior que o valor máximo, o valor alto é igual ao valor máximo.

func (*TagMeter) Id 

func (e *TagMeter) Id(id string) (ref *TagMeter)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagMeter) InputMode 

func (e *TagMeter) InputMode(inputMode InputMode) (ref *TagMeter)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagMeter) Is 

func (e *TagMeter) Is(is string) (ref *TagMeter)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagMeter) ItemDrop 

func (e *TagMeter) ItemDrop(itemprop string) (ref *TagMeter)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagMeter) ItemId 

func (e *TagMeter) ItemId(id string) (ref *TagMeter)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagMeter) ItemRef 

func (e *TagMeter) ItemRef(itemref string) (ref *TagMeter)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagMeter) ItemType 

func (e *TagMeter) ItemType(itemType string) (ref *TagMeter)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagMeter) Lang 

func (e *TagMeter) Lang(language Language) (ref *TagMeter)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagMeter) Low 

func (e *TagMeter) Low(value float64) (ref *TagMeter)

Low

English: 

The upper numeric bound of the low end of the measured range. This must be greater than the
minimum value (min attribute), and it also must be less than the high value and maximum value
(high attribute and max attribute, respectively), if any are specified. If unspecified, or if
less than the minimum value, the low value is equal to the minimum value.

Português: 

O limite numérico superior da extremidade inferior do intervalo medido. Isso deve ser maior que o
valor mínimo (atributo min) e também deve ser menor que o valor alto e o valor máximo
(atributo alto e atributo max, respectivamente), se algum for especificado. Se não especificado,
ou se for menor que o valor mínimo, o valor baixo é igual ao valor mínimo.

func (*TagMeter) Max 

func (e *TagMeter) Max(value float64) (ref *TagMeter)

Max

English: 

The upper numeric bound of the measured range. This must be greater than the minimum value
(min attribute), if specified. If unspecified, the maximum value is 1.

Português: 

O limite numérico superior do intervalo medido. Deve ser maior que o valor mínimo
(atributo min), se especificado. Se não especificado, o valor máximo é 1.

func (*TagMeter) Min 

func (e *TagMeter) Min(value float64) (ref *TagMeter)

Min

English: 

The lower numeric bound of the measured range. This must be less than the maximum value
(max attribute), if specified. If unspecified, the minimum value is 0.

Português: 

O limite numérico inferior do intervalo medido. Isso deve ser menor que o valor máximo
(atributo max), se especificado. Se não especificado, o valor mínimo é 0.

func (*TagMeter) Nonce 

func (e *TagMeter) Nonce(part ...string) (ref *TagMeter)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagMeter) Optimum 

func (e *TagMeter) Optimum(value float64) (ref *TagMeter)

Optimum

English: 

This attribute indicates the optimal numeric value. It must be within the range (as defined by the
min attribute and max attribute). When used with the low attribute and high attribute, it gives an
indication where along the range is considered preferable. For example, if it is between the min
attribute and the low attribute, then the lower range is considered preferred. The browser may
color the meter's bar differently depending on whether the value is less than or equal to the
optimum value.

Português: 

Este atributo indica o valor numérico ideal. Deve estar dentro do intervalo (conforme definido
pelo atributo min e atributo max). Quando usado com o atributo baixo e o atributo alto, fornece
uma indicação de onde ao longo do intervalo é considerado preferível. Por exemplo, se estiver
entre o atributo min e o atributo low, o intervalo inferior será considerado preferencial.
O navegador pode colorir a barra do medidor de forma diferente dependendo se o valor é menor ou
igual ao valor ideal.

func (*TagMeter) SetX 

func (e *TagMeter) SetX(x int) (ref *TagMeter)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagMeter) SetXY 

func (e *TagMeter) SetXY(x, y int) (ref *TagMeter)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagMeter) SetY 

func (e *TagMeter) SetY(y int) (ref *TagMeter)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagMeter) Slot 

func (e *TagMeter) Slot(slot string) (ref *TagMeter)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagMeter) Spellcheck 

func (e *TagMeter) Spellcheck(spell bool) (ref *TagMeter)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagMeter) Style 

func (e *TagMeter) Style(style string) (ref *TagMeter)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagMeter) TabIndex 

func (e *TagMeter) TabIndex(index int) (ref *TagMeter)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagMeter) Title 

func (e *TagMeter) Title(title string) (ref *TagMeter)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagMeter) Translate 

func (e *TagMeter) Translate(translate Translate) (ref *TagMeter)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagMeter) Value 

func (e *TagMeter) Value(value float64) (ref *TagMeter)

Value

English: 

The current numeric value. This must be between the minimum and maximum values (min attribute and
max attribute) if they are specified. If unspecified or malformed, the value is 0. If specified,
but not within the range given by the min attribute and max attribute, the value is equal to the
nearest end of the range.

 Note:
   * Unless the value attribute is between 0 and 1 (inclusive), the min and max attributes should
     define the range so that the value attribute's value is within it.

Português: 

O valor numérico atual. Deve estar entre os valores mínimo e máximo (atributo min e atributo max)
se forem especificados. Se não especificado ou malformado, o valor é 0. Se especificado, mas não
dentro do intervalo fornecido pelos atributos min e max, o valor é igual à extremidade mais
próxima do intervalo.

 Nota:
   * A menos que o atributo value esteja entre 0 e 1 (inclusive), os atributos min e max devem
     definir o intervalo para que o valor do atributo value esteja dentro dele.

type TagOptionGroup 

type TagOptionGroup struct {
	// contains filtered or unexported fields
}

func (*TagOptionGroup) AccessKey 

func (e *TagOptionGroup) AccessKey(key string) (ref *TagOptionGroup)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagOptionGroup) Append 

func (e *TagOptionGroup) Append(append interface{}) (ref *TagOptionGroup)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagOptionGroup) AppendById 

func (e *TagOptionGroup) AppendById(appendId string) (ref *TagOptionGroup)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagOptionGroup) Autofocus 

func (e *TagOptionGroup) Autofocus(autofocus bool) (ref *TagOptionGroup)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagOptionGroup) Class 

func (e *TagOptionGroup) Class(class ...string) (ref *TagOptionGroup)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagOptionGroup) ContentEditable 

func (e *TagOptionGroup) ContentEditable(editable bool) (ref *TagOptionGroup)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagOptionGroup) CreateElement 

func (e *TagOptionGroup) CreateElement(tag Tag) (ref *TagOptionGroup)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagOptionGroup) Data 

func (e *TagOptionGroup) Data(data map[string]string) (ref *TagOptionGroup)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagOptionGroup) Dir 

func (e *TagOptionGroup) Dir(dir Dir) (ref *TagOptionGroup)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagOptionGroup) Disabled 

func (e *TagOptionGroup) Disabled(disabled bool) (ref *TagOptionGroup)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagOptionGroup) Draggable 

func (e *TagOptionGroup) Draggable(draggable Draggable) (ref *TagOptionGroup)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagOptionGroup) EnterKeyHint 

func (e *TagOptionGroup) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagOptionGroup)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagOptionGroup) GetX 

func (e *TagOptionGroup) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagOptionGroup) GetXY 

func (e *TagOptionGroup) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagOptionGroup) GetY 

func (e *TagOptionGroup) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagOptionGroup) Hidden 

func (e *TagOptionGroup) Hidden() (ref *TagOptionGroup)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagOptionGroup) Id 

func (e *TagOptionGroup) Id(id string) (ref *TagOptionGroup)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagOptionGroup) InputMode 

func (e *TagOptionGroup) InputMode(inputMode InputMode) (ref *TagOptionGroup)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagOptionGroup) Is 

func (e *TagOptionGroup) Is(is string) (ref *TagOptionGroup)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagOptionGroup) ItemDrop 

func (e *TagOptionGroup) ItemDrop(itemprop string) (ref *TagOptionGroup)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagOptionGroup) ItemId 

func (e *TagOptionGroup) ItemId(id string) (ref *TagOptionGroup)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagOptionGroup) ItemRef 

func (e *TagOptionGroup) ItemRef(itemref string) (ref *TagOptionGroup)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagOptionGroup) ItemType 

func (e *TagOptionGroup) ItemType(itemType string) (ref *TagOptionGroup)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagOptionGroup) Label 

func (e *TagOptionGroup) Label(label string) (ref *TagOptionGroup)

Label

English: 

The name of the group of options, which the browser can use when labeling the options in the user
interface. This attribute is mandatory if this element is used.

Português: 

O nome do grupo de opções, que o navegador pode usar ao rotular as opções na interface do usuário.
Este atributo é obrigatório se este elemento for usado.

func (*TagOptionGroup) Lang 

func (e *TagOptionGroup) Lang(language Language) (ref *TagOptionGroup)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagOptionGroup) Nonce 

func (e *TagOptionGroup) Nonce(part ...string) (ref *TagOptionGroup)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagOptionGroup) SetX 

func (e *TagOptionGroup) SetX(x int) (ref *TagOptionGroup)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagOptionGroup) SetXY 

func (e *TagOptionGroup) SetXY(x, y int) (ref *TagOptionGroup)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagOptionGroup) SetY 

func (e *TagOptionGroup) SetY(y int) (ref *TagOptionGroup)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagOptionGroup) Slot 

func (e *TagOptionGroup) Slot(slot string) (ref *TagOptionGroup)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagOptionGroup) Spellcheck 

func (e *TagOptionGroup) Spellcheck(spell bool) (ref *TagOptionGroup)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagOptionGroup) Style 

func (e *TagOptionGroup) Style(style string) (ref *TagOptionGroup)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagOptionGroup) TabIndex 

func (e *TagOptionGroup) TabIndex(index int) (ref *TagOptionGroup)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagOptionGroup) Title 

func (e *TagOptionGroup) Title(title string) (ref *TagOptionGroup)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagOptionGroup) Translate 

func (e *TagOptionGroup) Translate(translate Translate) (ref *TagOptionGroup)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

type TagOutput 

type TagOutput struct {
	// contains filtered or unexported fields
}

func (*TagOutput) AccessKey 

func (e *TagOutput) AccessKey(key string) (ref *TagOutput)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagOutput) Append 

func (e *TagOutput) Append(append interface{}) (ref *TagOutput)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagOutput) AppendById 

func (e *TagOutput) AppendById(appendId string) (ref *TagOutput)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagOutput) Autofocus 

func (e *TagOutput) Autofocus(autofocus bool) (ref *TagOutput)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagOutput) Class 

func (e *TagOutput) Class(class ...string) (ref *TagOutput)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagOutput) ContentEditable 

func (e *TagOutput) ContentEditable(editable bool) (ref *TagOutput)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagOutput) CreateElement 

func (e *TagOutput) CreateElement(tag Tag) (ref *TagOutput)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagOutput) Data 

func (e *TagOutput) Data(data map[string]string) (ref *TagOutput)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagOutput) Dir 

func (e *TagOutput) Dir(dir Dir) (ref *TagOutput)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagOutput) Draggable 

func (e *TagOutput) Draggable(draggable Draggable) (ref *TagOutput)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagOutput) EnterKeyHint 

func (e *TagOutput) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagOutput)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagOutput) For 

func (e *TagOutput) For(value string) (ref *TagOutput)

For

English: 

The value of the for attribute must be a single id for a labelable form-related element in the
same document as the <label> element. So, any given label element can be associated with only
one form control.

 Note:
   * To programmatically set the for attribute, use htmlFor.

The first element in the document with an id attribute matching the value of the for attribute is the labeled control for this label element — if the element with that id is actually a labelable element. If it is not a labelable element, then the for attribute has no effect. If there are other elements that also match the id value, later in the document, they are not considered.

Multiple label elements can be given the same value for their for attribute; doing so causes the associated form control (the form control that for value references) to have multiple labels. 

Note:
  * A <label> element can have both a for attribute and a contained control element, as long as
    the for attribute points to the contained control element.

Português: 

O valor do atributo for deve ser um único id para um elemento rotulável relacionado ao formulário
no mesmo documento que o elemento <label>. Portanto, qualquer elemento de rótulo pode ser
associado a apenas um controle de formulário.

 Nota:
   * Programaticamente definir o atributo for, use htmlFor.

O primeiro elemento no documento com um atributo id correspondente ao valor do atributo é o controle rotulado para este elemento label - se o elemento com esse ID é realmente um elemento labelable. Se não é um elemento labelable, em seguida, o atributo for tem nenhum efeito. Se existem outros elementos que também correspondem ao valor id, mais adiante no documento, eles não são considerados.

Vários elementos de rótulo podem receber o mesmo valor para seu atributo for; isso faz com que o controle de formulário associado (o controle de formulário para referências de valor) tenha vários rótulos. 

Nota:
  * Um elemento <label> pode ter um atributo for e um elemento de controle contido, desde que
    o atributo for aponte para o elemento de controle contido.

func (*TagOutput) Form 

func (e *TagOutput) Form(form string) (ref *TagOutput)

Form

English: 

The <form> element to associate the output with (its form owner). The value of this attribute must
be the id of a <form> in the same document.

 Note:
   * If this attribute is not set, the <output> is associated with its ancestor <form> element,
     if any;
   * This attribute lets you associate <output> elements to <form>s anywhere in the document, not
     just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar a saída (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento.

 Nota:
   * Se este atributo não for definido, o <output> será associado ao elemento <form> ancestral,
     se houver;
   * Este atributo permite associar elementos <output> a <form>s em qualquer lugar do documento,
     não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagOutput) GetX 

func (e *TagOutput) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagOutput) GetXY 

func (e *TagOutput) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagOutput) GetY 

func (e *TagOutput) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagOutput) Hidden 

func (e *TagOutput) Hidden() (ref *TagOutput)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagOutput) Id 

func (e *TagOutput) Id(id string) (ref *TagOutput)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagOutput) InputMode 

func (e *TagOutput) InputMode(inputMode InputMode) (ref *TagOutput)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagOutput) Is 

func (e *TagOutput) Is(is string) (ref *TagOutput)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagOutput) ItemDrop 

func (e *TagOutput) ItemDrop(itemprop string) (ref *TagOutput)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagOutput) ItemId 

func (e *TagOutput) ItemId(id string) (ref *TagOutput)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagOutput) ItemRef 

func (e *TagOutput) ItemRef(itemref string) (ref *TagOutput)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagOutput) ItemType 

func (e *TagOutput) ItemType(itemType string) (ref *TagOutput)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagOutput) Lang 

func (e *TagOutput) Lang(language Language) (ref *TagOutput)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagOutput) Name 

func (e *TagOutput) Name(name string) (ref *TagOutput)

Name

English: 

The element's name. Used in the form.elements API.

Português: 

O nome do elemento. Usado na API form.elements.

func (*TagOutput) Nonce 

func (e *TagOutput) Nonce(part ...string) (ref *TagOutput)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagOutput) SetX 

func (e *TagOutput) SetX(x int) (ref *TagOutput)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagOutput) SetXY 

func (e *TagOutput) SetXY(x, y int) (ref *TagOutput)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagOutput) SetY 

func (e *TagOutput) SetY(y int) (ref *TagOutput)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagOutput) Slot 

func (e *TagOutput) Slot(slot string) (ref *TagOutput)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagOutput) Spellcheck 

func (e *TagOutput) Spellcheck(spell bool) (ref *TagOutput)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagOutput) Style 

func (e *TagOutput) Style(style string) (ref *TagOutput)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagOutput) TabIndex 

func (e *TagOutput) TabIndex(index int) (ref *TagOutput)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagOutput) Title 

func (e *TagOutput) Title(title string) (ref *TagOutput)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagOutput) Translate 

func (e *TagOutput) Translate(translate Translate) (ref *TagOutput)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

type TagSelect 

type TagSelect struct {
	// contains filtered or unexported fields
}

func (*TagSelect) AccessKey 

func (e *TagSelect) AccessKey(key string) (ref *TagSelect)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagSelect) Append 

func (e *TagSelect) Append(append interface{}) (ref *TagSelect)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagSelect) AppendById 

func (e *TagSelect) AppendById(appendId string) (ref *TagSelect)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagSelect) Autocomplete 

func (e *TagSelect) Autocomplete(autocomplete Autocomplete) (ref *TagSelect)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagSelect) Autofocus 

func (e *TagSelect) Autofocus(autofocus bool) (ref *TagSelect)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagSelect) Class 

func (e *TagSelect) Class(class ...string) (ref *TagSelect)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagSelect) ContentEditable 

func (e *TagSelect) ContentEditable(editable bool) (ref *TagSelect)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagSelect) CreateElement 

func (e *TagSelect) CreateElement(tag Tag) (ref *TagSelect)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagSelect) Data 

func (e *TagSelect) Data(data map[string]string) (ref *TagSelect)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagSelect) Dir 

func (e *TagSelect) Dir(dir Dir) (ref *TagSelect)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagSelect) Disabled 

func (e *TagSelect) Disabled(disabled bool) (ref *TagSelect)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagSelect) Draggable 

func (e *TagSelect) Draggable(draggable Draggable) (ref *TagSelect)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagSelect) EnterKeyHint 

func (e *TagSelect) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagSelect)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagSelect) Form 

func (e *TagSelect) Form(form string) (ref *TagSelect)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagSelect) GetX 

func (e *TagSelect) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagSelect) GetXY 

func (e *TagSelect) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagSelect) GetY 

func (e *TagSelect) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagSelect) Hidden 

func (e *TagSelect) Hidden() (ref *TagSelect)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagSelect) Id 

func (e *TagSelect) Id(id string) (ref *TagSelect)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagSelect) InputMode 

func (e *TagSelect) InputMode(inputMode InputMode) (ref *TagSelect)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagSelect) Is 

func (e *TagSelect) Is(is string) (ref *TagSelect)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagSelect) ItemDrop 

func (e *TagSelect) ItemDrop(itemprop string) (ref *TagSelect)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagSelect) ItemId 

func (e *TagSelect) ItemId(id string) (ref *TagSelect)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagSelect) ItemRef 

func (e *TagSelect) ItemRef(itemref string) (ref *TagSelect)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagSelect) ItemType 

func (e *TagSelect) ItemType(itemType string) (ref *TagSelect)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagSelect) Lang 

func (e *TagSelect) Lang(language Language) (ref *TagSelect)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagSelect) Multiple 

func (e *TagSelect) Multiple(multiple bool) (ref *TagSelect)

Multiple

English: 

This Boolean attribute indicates that multiple options can be selected in the list. If it is not
specified, then only one option can be selected at a time. When multiple is specified, most
browsers will show a scrolling list box instead of a single line dropdown.

Português: 

Este atributo booleano indica que várias opções podem ser selecionadas na lista. Se não for
especificado, apenas uma opção pode ser selecionada por vez. Quando vários são especificados, a
maioria dos navegadores mostrará uma caixa de listagem de rolagem em vez de uma lista suspensa
de uma única linha.

func (*TagSelect) Name 

func (e *TagSelect) Name(name string) (ref *TagSelect)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagSelect) NewOption 

func (e *TagSelect) NewOption(id, label, value string, disabled, selected bool) (ref *TagSelect)

NewOption

English: 

The <option> HTML element is used to define an item contained in a <select>, an <optgroup>, or
a <datalist> element. As such, <option> can represent menu items in popups and other lists of
items in an HTML document.

 Input:
   id: a unique id for an element;
   label: This attribute is text for the label indicating the meaning of the option. If the label
     attribute isn't defined, its value is that of the element text content;
   value: The content of this attribute represents the value to be submitted with the form, should
     this option be selected. If this attribute is omitted, the value is taken from the text
     content of the option element;
   disabled: If this Boolean attribute is set, this option is not checkable. Often browsers grey
     out such control and it won't receive any browsing event, like mouse clicks or focus-related
     ones. If this attribute is not set, the element can still be disabled if one of its ancestors
     is a disabled <optgroup> element;
   selected: If present, this Boolean attribute indicates that the option is initially selected.
     If the <option> element is the descendant of a <select> element whose multiple attribute is
     not set, only one single <option> of this <select> element may have the selected attribute.

 Nota:
   * The new option will be created inside the last NewOptionGroup() created. Use the
     ReleaseGroup() function to create the new option at the root.

Português: 

O elemento HTML <option> é usado para definir um item contido em um elemento <select>, <optgroup>
ou <datalist>. Como tal, <option> pode representar itens de menu em pop-ups e outras listas de
itens em um documento HTML.

 Entrada:
   id: um id exclusivo para um elemento;
   label: Este atributo é um texto para o rótulo que indica o significado da opção. Se o atributo
     label não estiver definido, seu valor será o do conteúdo do texto do elemento;
   value: O conteúdo deste atributo representa o valor a ser enviado com o formulário, caso esta
     opção seja selecionada. Se este atributo for omitido, o valor será obtido do conteúdo de
     texto do elemento de opção;
   disabled: Se este atributo booleano estiver definido, esta opção não poderá ser marcada.
     Muitas vezes, os navegadores desativam esse controle e não recebem nenhum evento de
     navegação, como cliques do mouse ou relacionados ao foco. Se este atributo não for definido,
     o elemento ainda poderá ser desabilitado se um de seus ancestrais for um elemento <optgroup>
     desabilitado;
   selected: Se presente, este atributo booleano indica que a opção foi selecionada inicialmente.
     Se o elemento <option> é descendente de um elemento <select> cujo atributo múltiplo não está
     definido, apenas um único <option> deste elemento <select> pode ter o atributo selecionado.

 Nota:
   * O novo option será criado dentro do último NewOptionGroup() criado. Use a função
     ReleaseGroup() para criar o novo option na raiz.

func (*TagSelect) NewOptionGroup 

func (e *TagSelect) NewOptionGroup(id, label string, disabled bool) (ref *TagSelect)

func (*TagSelect) Nonce 

func (e *TagSelect) Nonce(part ...string) (ref *TagSelect)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagSelect) ReleaseGroup 

func (e *TagSelect) ReleaseGroup() (ref *TagSelect)

ReleaseGroup

English: 

Releases the new option from the last option group created.

Português: 

Libera o novo option do último option group criado.

func (*TagSelect) Required 

func (e *TagSelect) Required(required bool) (ref *TagSelect)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagSelect) SetX 

func (e *TagSelect) SetX(x int) (ref *TagSelect)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagSelect) SetXY 

func (e *TagSelect) SetXY(x, y int) (ref *TagSelect)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagSelect) SetY 

func (e *TagSelect) SetY(y int) (ref *TagSelect)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagSelect) Size 

func (e *TagSelect) Size(size int) (ref *TagSelect)

Size

English: 

If the control is presented as a scrolling list box (e.g. when multiple is specified), this
attribute represents the number of rows in the list that should be visible at one time.
Browsers are not required to present a select element as a scrolled list box. The default value
is 0.

 Note:
   * According to the HTML5 specification, the default value for size should be 1; however, in
     practice, this has been found to break some web sites, and no other browser currently does
     that, so Mozilla has opted to continue to return 0 for the time being with Firefox.

Português: 

Se o controle for apresentado como uma caixa de listagem de rolagem (por exemplo, quando múltiplo
é especificado), esse atributo representa o número de linhas na lista que devem estar visíveis ao
mesmo tempo. Os navegadores não precisam apresentar um elemento de seleção como uma caixa de
listagem rolada. O valor padrão é 0.

 Nota:
   * De acordo com a especificação HTML5, o valor padrão para tamanho deve ser 1; no entanto, na
     prática, descobriu-se que isso quebra alguns sites, e nenhum outro navegador atualmente faz
     isso, então a Mozilla optou por continuar retornando 0 por enquanto com o Firefox.

func (*TagSelect) Slot 

func (e *TagSelect) Slot(slot string) (ref *TagSelect)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagSelect) Spellcheck 

func (e *TagSelect) Spellcheck(spell bool) (ref *TagSelect)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagSelect) Style 

func (e *TagSelect) Style(style string) (ref *TagSelect)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagSelect) TabIndex 

func (e *TagSelect) TabIndex(index int) (ref *TagSelect)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagSelect) Title 

func (e *TagSelect) Title(title string) (ref *TagSelect)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagSelect) Translate 

func (e *TagSelect) Translate(translate Translate) (ref *TagSelect)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

type TagSvg 

type TagSvg struct {
	// contains filtered or unexported fields
}

TagSvg

English:

The svg element is a container that defines a new coordinate system and viewport. It is used as the outermost element of SVG documents, but it can also be used to embed an SVG fragment inside an SVG or HTML document. 

Notes:
  * The xmlns attribute is only required on the outermost svg element of SVG documents. It is unnecessary for inner
    svg elements or inside HTML documents.

Português:

O elemento svg é um contêiner que define um novo sistema de coordenadas e viewport. Ele é usado como o elemento mais externo dos documentos SVG, mas também pode ser usado para incorporar um fragmento SVG dentro de um documento SVG ou HTML. 

Notas:
  * O atributo xmlns só é necessário no elemento svg mais externo dos documentos SVG. É desnecessário para
    elementos svg internos ou dentro de documentos HTML.

func (*TagSvg) Append 

func (e *TagSvg) Append(elements ...Compatible) (ref *TagSvg)

func (*TagSvg) AppendById 

func (e *TagSvg) AppendById(appendId string) (ref *TagSvg)

func (*TagSvg) AppendToElement 

func (e *TagSvg) AppendToElement(el js.Value) (ref *TagSvg)

func (*TagSvg) AppendToStage 

func (e *TagSvg) AppendToStage() (ref *TagSvg)

func (*TagSvg) BaselineShift 

func (e *TagSvg) BaselineShift(baselineShift interface{}) (ref *TagSvg)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvg) Class 

func (e *TagSvg) Class(class string) (ref *TagSvg)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvg) ClipPath 

func (e *TagSvg) ClipPath(clipPath string) (ref *TagSvg)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvg) ClipRule 

func (e *TagSvg) ClipRule(value interface{}) (ref *TagSvg)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvg) Color 

func (e *TagSvg) Color(value interface{}) (ref *TagSvg)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvg) ColorInterpolation 

func (e *TagSvg) ColorInterpolation(value interface{}) (ref *TagSvg)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvg) ColorInterpolationFilters 

func (e *TagSvg) ColorInterpolationFilters(value interface{}) (ref *TagSvg)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvg) CreateElement 

func (e *TagSvg) CreateElement() (ref *TagSvg)

func (*TagSvg) Cursor 

func (e *TagSvg) Cursor(cursor SvgCursor) (ref *TagSvg)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvg) Direction 

func (e *TagSvg) Direction(direction SvgDirection) (ref *TagSvg)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvg) Display 

func (e *TagSvg) Display(value interface{}) (ref *TagSvg)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvg) DominantBaseline 

func (e *TagSvg) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvg)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvg) Fill 

func (e *TagSvg) Fill(value interface{}) (ref *TagSvg)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvg) FillOpacity 

func (e *TagSvg) FillOpacity(value interface{}) (ref *TagSvg)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvg) FillRule 

func (e *TagSvg) FillRule(fillRule SvgFillRule) (ref *TagSvg)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvg) Filter 

func (e *TagSvg) Filter(filter string) (ref *TagSvg)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvg) FloodColor 

func (e *TagSvg) FloodColor(floodColor interface{}) (ref *TagSvg)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvg) FloodOpacity 

func (e *TagSvg) FloodOpacity(floodOpacity float64) (ref *TagSvg)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvg) FontFamily 

func (e *TagSvg) FontFamily(fontFamily string) (ref *TagSvg)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvg) FontSize 

func (e *TagSvg) FontSize(fontSize interface{}) (ref *TagSvg)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvg) FontSizeAdjust 

func (e *TagSvg) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvg)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvg) FontStretch 

func (e *TagSvg) FontStretch(fontStretch interface{}) (ref *TagSvg)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvg) FontStyle 

func (e *TagSvg) FontStyle(fontStyle FontStyleRule) (ref *TagSvg)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvg) FontVariant 

func (e *TagSvg) FontVariant(value interface{}) (ref *TagSvg)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvg) FontWeight 

func (e *TagSvg) FontWeight(value interface{}) (ref *TagSvg)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvg) Get 

func (e *TagSvg) Get() (el js.Value)

func (*TagSvg) Height 

func (e *TagSvg) Height(height interface{}) (ref *TagSvg)

Height

English: 

The height attribute defines the vertical length of an element in the user coordinate system.
     float32: 1.0 = "100%"
     any other type: interface{}

Português: 

O atributo height define o comprimento vertical de um elemento no sistema de coordenadas do usuário.
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

func (*TagSvg) Html 

func (e *TagSvg) Html(value string) (ref *TagSvg)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvg) Id 

func (e *TagSvg) Id(id string) (ref *TagSvg)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvg) ImageRendering 

func (e *TagSvg) ImageRendering(imageRendering string) (ref *TagSvg)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvg) Init 

func (e *TagSvg) Init() (ref *TagSvg)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvg) Lang 

func (e *TagSvg) Lang(value interface{}) (ref *TagSvg)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvg) LetterSpacing 

func (e *TagSvg) LetterSpacing(value float64) (ref *TagSvg)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvg) LightingColor 

func (e *TagSvg) LightingColor(value interface{}) (ref *TagSvg)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvg) MarkerEnd 

func (e *TagSvg) MarkerEnd(value interface{}) (ref *TagSvg)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvg) MarkerMid 

func (e *TagSvg) MarkerMid(value interface{}) (ref *TagSvg)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvg) MarkerStart 

func (e *TagSvg) MarkerStart(value interface{}) (ref *TagSvg)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvg) Mask 

func (e *TagSvg) Mask(value interface{}) (ref *TagSvg)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvg) Opacity 

func (e *TagSvg) Opacity(value interface{}) (ref *TagSvg)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvg) Overflow 

func (e *TagSvg) Overflow(value interface{}) (ref *TagSvg)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvg) PointerEvents 

func (e *TagSvg) PointerEvents(value interface{}) (ref *TagSvg)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvg) PreserveAspectRatio 

func (e *TagSvg) PreserveAspectRatio(ratio, meet interface{}) (ref *TagSvg)

PreserveAspectRatio

English: 

The preserveAspectRatio attribute indicates how an element with a viewBox providing a given aspect ratio must fit
into a viewport with a different aspect ratio.

 Input:
   ratio: Indicates how an element with a viewBox providing a given aspect ratio.
     const: KRatio... (e.g. KRatioXMinYMin)
     any other type: interface{}
   meet: The meet or slice reference
     const: KMeetOrSliceReference... (e.g. KMeetOrSliceReferenceSlice)
     any other type: interface{}

Because the aspect ratio of an SVG image is defined by the viewBox attribute, if this attribute isn't set, the preserveAspectRatio attribute has no effect (with one exception, the <image> element, as described below). 

Notes:
  * Use ratio and meet equal to nil for preserveAspectRatio="none"

Português: 

O atributo preserveAspectRatio indica como um elemento com uma viewBox fornecendo uma determinada proporção deve
caber em uma viewport com uma proporção diferente.

 Input:
   ratio: Indica como um elemento com uma viewBox fornece uma determinada proporção.
     const: KRatio... (ex. KRatioXMinYMin)
     qualquer outro tipo: interface{}
   meet: A referência de encontro ou fatia
     const: KMeetOrSliceReference... (ex. KMeetOrSliceReferenceSlice)
     qualquer outro tipo: interface{}

Como a proporção de uma imagem SVG é definida pelo atributo viewBox, se esse atributo não estiver definido, o atributo preserveAspectRatio não terá efeito (com uma exceção, o elemento <image>, conforme descrito abaixo). 

Notas:
  * Use ratio e meet igual a para for preserveAspectRatio="none"

func (*TagSvg) ShapeRendering 

func (e *TagSvg) ShapeRendering(value interface{}) (ref *TagSvg)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvg) StopColor 

func (e *TagSvg) StopColor(value interface{}) (ref *TagSvg)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvg) StopOpacity 

func (e *TagSvg) StopOpacity(value interface{}) (ref *TagSvg)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvg) Stroke 

func (e *TagSvg) Stroke(value interface{}) (ref *TagSvg)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvg) StrokeDasharray 

func (e *TagSvg) StrokeDasharray(value interface{}) (ref *TagSvg)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvg) StrokeLineCap 

func (e *TagSvg) StrokeLineCap(value interface{}) (ref *TagSvg)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvg) StrokeLineJoin 

func (e *TagSvg) StrokeLineJoin(value interface{}) (ref *TagSvg)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvg) StrokeMiterLimit 

func (e *TagSvg) StrokeMiterLimit(value float64) (ref *TagSvg)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvg) StrokeOpacity 

func (e *TagSvg) StrokeOpacity(value interface{}) (ref *TagSvg)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvg) StrokeWidth 

func (e *TagSvg) StrokeWidth(value interface{}) (ref *TagSvg)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvg) Style 

func (e *TagSvg) Style(value string) (ref *TagSvg)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvg) Tabindex 

func (e *TagSvg) Tabindex(value int) (ref *TagSvg)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvg) Text 

func (e *TagSvg) Text(value string) (ref *TagSvg)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvg) TextAnchor 

func (e *TagSvg) TextAnchor(value interface{}) (ref *TagSvg)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvg) TextDecoration 

func (e *TagSvg) TextDecoration(value interface{}) (ref *TagSvg)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvg) TextRendering 

func (e *TagSvg) TextRendering(value interface{}) (ref *TagSvg)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvg) Transform 

func (e *TagSvg) Transform(value interface{}) (ref *TagSvg)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvg) UnicodeBidi 

func (e *TagSvg) UnicodeBidi(value interface{}) (ref *TagSvg)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvg) VectorEffect 

func (e *TagSvg) VectorEffect(value interface{}) (ref *TagSvg)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvg) ViewBox 

func (e *TagSvg) ViewBox(value interface{}) (ref *TagSvg)

ViewBox

English:

The viewBox attribute defines the position and dimension, in user space, of an SVG viewport. 

Input:
  value: defines the position and dimension, in user space, of an SVG viewport
    []float64: ex. []float64{0.0, 0.0, 10.0, 10.0} = "0 0 10 10"
    any other type: interface{}

The value of the viewBox attribute is a list of four numbers: min-x, min-y, width and height. The numbers, which are separated by whitespace and/or a comma, specify a rectangle in user space which is mapped to the bounds of the viewport established for the associated SVG element (not the browser viewport).

Português:

O atributo viewBox define a posição e a dimensão, no espaço do usuário, de uma viewport SVG. 

Input:
  value: define a posição e dimensão, no espaço do usuário, de uma viewport SVG
    []float64: ex. []float64{0.0, 0.0, 10.0, 10.0} = "0 0 10 10"
    qualquer outro tipo: interface{}

O valor do atributo viewBox é uma lista de quatro números: min-x, min-y, largura e altura. Os números, que são separados por espaço em branco e ou vírgula, especificam um retângulo no espaço do usuário que é mapeado para os limites da janela de visualização estabelecida para o elemento SVG associado (não a janela de visualização do navegador).

func (*TagSvg) Visibility 

func (e *TagSvg) Visibility(value interface{}) (ref *TagSvg)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvg) Width 

func (e *TagSvg) Width(value interface{}) (ref *TagSvg)

Width

English:

The width attribute defines the horizontal length of an element in the user coordinate system. 

Input:
  value: the horizontal length of an element
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo largura define o comprimento horizontal de um elemento no sistema de coordenadas do usuário. 

Entrada:
  value: o comprimento horizontal de um elemento
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvg) WordSpacing 

func (e *TagSvg) WordSpacing(value interface{}) (ref *TagSvg)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvg) WritingMode 

func (e *TagSvg) WritingMode(value interface{}) (ref *TagSvg)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvg) X 

func (e *TagSvg) X(value interface{}) (ref *TagSvg)

X

English:

The x attribute defines an x-axis coordinate in the user coordinate system. 

Input:
  value: defines an x-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo x define uma coordenada do eixo x no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo x
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvg) XmlLang 

func (e *TagSvg) XmlLang(value interface{}) (ref *TagSvg)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado. 

func (e *TagSvg) XmlnsXLink(value string) (ref *TagSvg)

func (*TagSvg) Y 

func (e *TagSvg) Y(value interface{}) (ref *TagSvg)

Y

English:

The y attribute defines an y-axis coordinate in the user coordinate system. 

Input:
  value: defines an y-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo y define uma coordenada do eixo y no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo y
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

type TagSvgA 

type TagSvgA struct {
	// contains filtered or unexported fields
}

TagSvgA

English: 

The <a> SVG element creates a hyperlink to other web pages, files, locations in the same page, email addresses, or
any other URL. It is very similar to HTML's <a> element.

SVG's <a> element is a container, which means you can create a link around text (like in HTML) but also around any shape. 

Notes:
  * Since this element shares its tag name with HTML's <a> element, selecting a with CSS or querySelector may apply
    to the wrong kind of element. Try the @namespace rule to distinguish the two.

Português: 

O elemento SVG <a> cria um hiperlink para outras páginas da web, arquivos, locais na mesma página, endereços de
e-mail ou qualquer outro URL. É muito semelhante ao elemento <a> do HTML.

O elemento SVGs <a> é um contêiner, o que significa que você pode criar um link em torno do texto (como em HTML), mas também em torno de qualquer forma. 

Notes:
  * Como esse elemento compartilha seu nome de tag com o elemento <a> do HTML, selecionar a com CSS ou
    querySelector pode se aplicar ao tipo errado de elemento. Experimente a regra @namespace para distinguir os
    dois.

func (*TagSvgA) Append 

func (e *TagSvgA) Append(elements ...Compatible) (ref *TagSvgA)

func (*TagSvgA) AppendById 

func (e *TagSvgA) AppendById(appendId string) (ref *TagSvgA)

func (*TagSvgA) AppendToElement 

func (e *TagSvgA) AppendToElement(el js.Value) (ref *TagSvgA)

func (*TagSvgA) AppendToStage 

func (e *TagSvgA) AppendToStage() (ref *TagSvgA)

func (*TagSvgA) BaselineShift 

func (e *TagSvgA) BaselineShift(baselineShift interface{}) (ref *TagSvgA)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgA) Class 

func (e *TagSvgA) Class(class string) (ref *TagSvgA)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgA) ClipPath 

func (e *TagSvgA) ClipPath(clipPath string) (ref *TagSvgA)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgA) ClipRule 

func (e *TagSvgA) ClipRule(value interface{}) (ref *TagSvgA)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgA) Color 

func (e *TagSvgA) Color(value interface{}) (ref *TagSvgA)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgA) ColorInterpolation 

func (e *TagSvgA) ColorInterpolation(value interface{}) (ref *TagSvgA)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgA) ColorInterpolationFilters 

func (e *TagSvgA) ColorInterpolationFilters(value interface{}) (ref *TagSvgA)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgA) CreateElement 

func (e *TagSvgA) CreateElement() (ref *TagSvgA)

func (*TagSvgA) Cursor 

func (e *TagSvgA) Cursor(cursor SvgCursor) (ref *TagSvgA)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgA) Direction 

func (e *TagSvgA) Direction(direction SvgDirection) (ref *TagSvgA)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgA) Display 

func (e *TagSvgA) Display(value interface{}) (ref *TagSvgA)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgA) DominantBaseline 

func (e *TagSvgA) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgA)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgA) Fill 

func (e *TagSvgA) Fill(value interface{}) (ref *TagSvgA)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgA) FillOpacity 

func (e *TagSvgA) FillOpacity(value interface{}) (ref *TagSvgA)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgA) FillRule 

func (e *TagSvgA) FillRule(fillRule SvgFillRule) (ref *TagSvgA)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgA) Filter 

func (e *TagSvgA) Filter(filter string) (ref *TagSvgA)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgA) FloodColor 

func (e *TagSvgA) FloodColor(floodColor interface{}) (ref *TagSvgA)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgA) FloodOpacity 

func (e *TagSvgA) FloodOpacity(floodOpacity float64) (ref *TagSvgA)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgA) FontFamily 

func (e *TagSvgA) FontFamily(fontFamily string) (ref *TagSvgA)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgA) FontSize 

func (e *TagSvgA) FontSize(fontSize interface{}) (ref *TagSvgA)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgA) FontSizeAdjust 

func (e *TagSvgA) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgA)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgA) FontStretch 

func (e *TagSvgA) FontStretch(fontStretch interface{}) (ref *TagSvgA)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgA) FontStyle 

func (e *TagSvgA) FontStyle(fontStyle FontStyleRule) (ref *TagSvgA)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgA) FontVariant 

func (e *TagSvgA) FontVariant(value interface{}) (ref *TagSvgA)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgA) FontWeight 

func (e *TagSvgA) FontWeight(value interface{}) (ref *TagSvgA)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgA) Get 

func (e *TagSvgA) Get() (el js.Value)

func (*TagSvgA) HRef 

func (e *TagSvgA) HRef(href string) (ref *TagSvgA)

HRef

English: 

The href attribute defines a link to a resource as a reference URL. The exact meaning of that link depends on the
context of each element using it.

 Notes:
   * Specifications before SVG 2 defined an xlink:href attribute, which is now rendered obsolete by the href
     attribute.
     If you need to support earlier browser versions, the deprecated xlink:href attribute can be used as a fallback
     in addition to the href attribute, e.g. <use href="some-id" xlink:href="some-id x="5" y="5" />.

Português: 

O atributo href define um link para um recurso como um URL de referência. O significado exato desse link depende do
contexto de cada elemento que o utiliza.

 Notas:
   * As especificações anteriores ao SVG 2 definiam um atributo xlink:href, que agora se torna obsoleto pelo
     atributo href.
     Se você precisar oferecer suporte a versões anteriores do navegador, o atributo obsoleto xlink:href pode ser
     usado como um substituto além do atributo href, por exemplo,
     <use href="some-id" xlink:href="some-id x="5" y="5" />.

func (*TagSvgA) Html 

func (e *TagSvgA) Html(value string) (ref *TagSvgA)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgA) Id 

func (e *TagSvgA) Id(id string) (ref *TagSvgA)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgA) ImageRendering 

func (e *TagSvgA) ImageRendering(imageRendering string) (ref *TagSvgA)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgA) Init 

func (e *TagSvgA) Init() (ref *TagSvgA)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgA) Lang 

func (e *TagSvgA) Lang(value interface{}) (ref *TagSvgA)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgA) LetterSpacing 

func (e *TagSvgA) LetterSpacing(value float64) (ref *TagSvgA)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgA) LightingColor 

func (e *TagSvgA) LightingColor(value interface{}) (ref *TagSvgA)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgA) MarkerEnd 

func (e *TagSvgA) MarkerEnd(value interface{}) (ref *TagSvgA)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgA) MarkerMid 

func (e *TagSvgA) MarkerMid(value interface{}) (ref *TagSvgA)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgA) MarkerStart 

func (e *TagSvgA) MarkerStart(value interface{}) (ref *TagSvgA)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgA) Mask 

func (e *TagSvgA) Mask(value interface{}) (ref *TagSvgA)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgA) Opacity 

func (e *TagSvgA) Opacity(value interface{}) (ref *TagSvgA)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgA) Overflow 

func (e *TagSvgA) Overflow(value interface{}) (ref *TagSvgA)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgA) PointerEvents 

func (e *TagSvgA) PointerEvents(value interface{}) (ref *TagSvgA)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgA) ShapeRendering 

func (e *TagSvgA) ShapeRendering(value interface{}) (ref *TagSvgA)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgA) StopColor 

func (e *TagSvgA) StopColor(value interface{}) (ref *TagSvgA)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgA) StopOpacity 

func (e *TagSvgA) StopOpacity(value interface{}) (ref *TagSvgA)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgA) Stroke 

func (e *TagSvgA) Stroke(value interface{}) (ref *TagSvgA)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgA) StrokeDasharray 

func (e *TagSvgA) StrokeDasharray(value interface{}) (ref *TagSvgA)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgA) StrokeLineCap 

func (e *TagSvgA) StrokeLineCap(value interface{}) (ref *TagSvgA)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgA) StrokeLineJoin 

func (e *TagSvgA) StrokeLineJoin(value interface{}) (ref *TagSvgA)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgA) StrokeMiterLimit 

func (e *TagSvgA) StrokeMiterLimit(value float64) (ref *TagSvgA)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgA) StrokeOpacity 

func (e *TagSvgA) StrokeOpacity(value interface{}) (ref *TagSvgA)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgA) StrokeWidth 

func (e *TagSvgA) StrokeWidth(value interface{}) (ref *TagSvgA)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgA) Style 

func (e *TagSvgA) Style(value string) (ref *TagSvgA)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgA) Tabindex 

func (e *TagSvgA) Tabindex(value int) (ref *TagSvgA)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgA) Target 

func (e *TagSvgA) Target(value interface{}) (ref *TagSvgA)

Target

English:

This attribute specifies the name of the browsing context (e.g., a browser tab or an (X)HTML iframe or object element) into which a document is to be opened when the link is activated 

Input:
  value: specifies the name of the browsing context
    const: KTarget... (e.g. KTargetSelf)
   any other type: interface{}

The target attribute should be used when there are multiple possible targets for the ending resource, such as when the parent document is embedded within an HTML or XHTML document, or is viewed with a tabbed browser.

Português:

Este atributo especifica o nome do contexto de navegação (por exemplo, uma guia do navegador ou um iframe ou elemento de objeto (X)HTML) no qual um documento deve ser aberto quando o link é ativado 

Entrada:
  value: especifica o nome do contexto de navegação
    const: KTarget... (e.g. KTargetSelf)
    qualquer outro tipo: interface{}

O atributo target deve ser usado quando houver vários destinos possíveis para o recurso final, como quando o documento pai estiver incorporado em um documento HTML ou XHTML ou for visualizado em um navegador com guias.

func (*TagSvgA) Text 

func (e *TagSvgA) Text(value string) (ref *TagSvgA)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgA) TextAnchor 

func (e *TagSvgA) TextAnchor(value interface{}) (ref *TagSvgA)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgA) TextDecoration 

func (e *TagSvgA) TextDecoration(value interface{}) (ref *TagSvgA)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgA) TextRendering 

func (e *TagSvgA) TextRendering(value interface{}) (ref *TagSvgA)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgA) Transform 

func (e *TagSvgA) Transform(value interface{}) (ref *TagSvgA)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgA) Type 

func (e *TagSvgA) Type(value interface{}) (ref *TagSvgA)

Type

English:

Hints at the linked URL's format with a MIME type. No built-in functionality.

Português:

Dicas no formato do URL vinculado com um tipo MIME. Nenhuma funcionalidade embutida.

func (*TagSvgA) UnicodeBidi 

func (e *TagSvgA) UnicodeBidi(value interface{}) (ref *TagSvgA)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgA) VectorEffect 

func (e *TagSvgA) VectorEffect(value interface{}) (ref *TagSvgA)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgA) Visibility 

func (e *TagSvgA) Visibility(value interface{}) (ref *TagSvgA)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgA) WordSpacing 

func (e *TagSvgA) WordSpacing(value interface{}) (ref *TagSvgA)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgA) WritingMode 

func (e *TagSvgA) WritingMode(value interface{}) (ref *TagSvgA)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgA) XLinkHRef deprecated 

func (e *TagSvgA) XLinkHRef(value interface{}) (ref *TagSvgA)

XLinkHRef

Deprecated: use HRef() function

English:

The xlink:href attribute defines a reference to a resource as a reference IRI. The exact meaning of that link depends on the context of each element using it. 

Notes:
  * SVG 2 removed the need for the xlink namespace, so instead of xlink:href you should use href. If you need to
    support earlier browser versions, the deprecated xlink:href attribute can be used as a fallback in addition to
    the href attribute, e.g. <use href="some-id" xlink:href="some-id" x="5" y="5" />.

Português:

Obsoleto: use a função HRef()

O atributo xlink:href define uma referência a um recurso como um IRI de referência. O significado exato desse link depende do contexto de cada elemento que o utiliza. 

Notas:
  * O SVG 2 removeu a necessidade do namespace xlink, então ao invés de xlink:href você deve usar href. Se você
    precisar oferecer suporte a versões anteriores do navegador, o atributo obsoleto xlink:href pode ser usado como
    um substituto além do atributo href, por exemplo, <use href="some-id" xlink:href="some-id" x="5" y="5" >.

func (*TagSvgA) XmlLang 

func (e *TagSvgA) XmlLang(value interface{}) (ref *TagSvgA)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

type TagSvgAnimate 

type TagSvgAnimate struct {
	// contains filtered or unexported fields
}

TagSvgAnimate

English: 

The SVG <animate> element provides a way to animate an attribute of an element over time.

Português: 

O elemento SVG <animate> fornece uma maneira de animar um atributo de um elemento ao longo do tempo.

func (*TagSvgAnimate) Accumulate 

func (e *TagSvgAnimate) Accumulate(value interface{}) (ref *TagSvgAnimate)

Accumulate

English: 

The accumulate attribute controls whether or not an animation is cumulative.

 Input:
   value: controls whether or not an animation is cumulative
     const: KSvgAccumulate... (e.g. KSvgAccumulateSum)
     any other type: interface{}

It is frequently useful for repeated animations to build upon the previous results, accumulating with each iteration. This attribute said to the animation if the value is added to the previous animated attribute's value on each iteration. 

Notes:
  * This attribute is ignored if the target attribute value does not support addition, or if the animation element
    does not repeat;
  * This attribute will be ignored if the animation function is specified with only the to attribute.

Português: 

O atributo acumular controla se uma animação é cumulativa ou não.

 Entrada:
   value: controla se uma animação é cumulativa ou não
     const: KSvgAccumulate... (ex. KSvgAccumulateSum)
     qualquer outro tipo: interface{}

Frequentemente, é útil que as animações repetidas se baseiem nos resultados anteriores, acumulando a cada iteração. Este atributo é dito à animação se o valor for adicionado ao valor do atributo animado anterior em cada iteração. 

Notas:
  * Esse atributo será ignorado se o valor do atributo de destino não suportar adição ou se o elemento de animação
    não se repetir;
  * Este atributo será ignorado se a função de animação for especificada apenas com o atributo to.

func (*TagSvgAnimate) Additive 

func (e *TagSvgAnimate) Additive(value interface{}) (ref *TagSvgAnimate)

Additive

English: 

The additive attribute controls whether or not an animation is additive.

 Input:
   value: controls whether or not an animation is additive
     const: KSvgAdditive... (e.g. KSvgAdditiveSum)
     any other type: interface{}

It is frequently useful to define animation as an offset or delta to an attribute's value, rather than as absolute values.

Português: 

O atributo aditivo controla se uma animação é ou não aditiva.

 Entrada:
   value: controla se uma animação é aditiva ou não
     const: KSvgAdditive... (ex. KSvgAdditiveSum)
     qualquer outro tipo: interface{}

É frequentemente útil definir a animação como um deslocamento ou delta para o valor de um atributo, em vez de valores absolutos.

func (*TagSvgAnimate) Append 

func (e *TagSvgAnimate) Append(elements ...Compatible) (ref *TagSvgAnimate)

func (*TagSvgAnimate) AppendById 

func (e *TagSvgAnimate) AppendById(appendId string) (ref *TagSvgAnimate)

func (*TagSvgAnimate) AppendToElement 

func (e *TagSvgAnimate) AppendToElement(el js.Value) (ref *TagSvgAnimate)

func (*TagSvgAnimate) AppendToStage 

func (e *TagSvgAnimate) AppendToStage() (ref *TagSvgAnimate)

func (*TagSvgAnimate) AttributeName 

func (e *TagSvgAnimate) AttributeName(attributeName string) (ref *TagSvgAnimate)

AttributeName

English: 

The attributeName attribute indicates the name of the CSS property or attribute of the target element that is going
to be changed during an animation.

Português: 

O atributo attributeName indica o nome da propriedade CSS ou atributo do elemento de destino que será alterado
durante uma animação.

func (*TagSvgAnimate) Begin 

func (e *TagSvgAnimate) Begin(begin interface{}) (ref *TagSvgAnimate)

Begin

English: 

The begin attribute defines when an animation should begin or when an element should be discarded.

 Input:
   begin: defines when an animation should begin or when an element should be discarded.
     offset-value: This value defines a clock-value that represents a point in time relative to the beginning of the
       SVG document (usually the load or DOMContentLoaded event). Negative values are valid.
       (e.g. time.Second*5 or "5s")
     syncbase-value: This value defines a syncbase and an optional offset from that syncbase. The element's
       animation start time is defined relative to the begin or active end of another animation.
       A valid syncbase-value consists of an ID reference to another animation element followed by a dot and either
       begin or end to identify whether to synchronize with the beginning or active end of the referenced animation
       element. An optional offset value as defined in <offset-value> can be appended.
       (e.g. "0s;third.end", "first.end" or "second.end")
     event-value: This value defines an event and an optional offset that determines the time at which the element's
       animation should begin. The animation start time is defined relative to the time that the specified event is
       fired.
       A valid event-value consists of an element ID followed by a dot and one of the supported events for that
       element. All valid events (not necessarily supported by all elements) are defined by the DOM and HTML
       specifications. Those are: 'focus', 'blur', 'focusin', 'focusout', 'activate', 'auxclick', 'click',
       'dblclick', 'mousedown', 'mouseenter', 'mouseleave', 'mousemove', 'mouseout', 'mouseover', 'mouseup',
       'wheel', 'beforeinput', 'input', 'keydown', 'keyup', 'compositionstart', 'compositionupdate',
       'compositionend', 'load', 'unload', 'abort', 'error', 'select', 'resize', 'scroll', 'beginEvent', 'endEvent',
       and 'repeatEvent'. An optional offset value as defined in <offset-value> can be appended.
       (e.g. "startButton.click")
     repeat-value: This value defines a qualified repeat event. The element animation start time is defined relative
       to the time that the repeat event is raised with the specified iteration value.
       A valid repeat value consists of an element ID followed by a dot and the function repeat() with an integer
       value specifying the number of repetitions as parameter. An optional offset value as defined in
       <offset-value> can be appended.
       (e.g. "0s;myLoop.end", "myLoop.begin", "myLoop.repeat(1)" or "myLoop.repeat(2)")
     accessKey-value: This value defines an access key that should trigger the animation. The element animation will
       begin when the user presses the specified key.
       A valid accessKey-value consists of the function accessKey() with the character to be input as parameter. An
       optional offset value as defined in <offset-value> can be appended.
       (e.g. "accessKey(s)")
     wallclock-sync-value: This value defines the animation start time as a real-world clock time.
       A valid wallclock-sync-value consists of the function wallclock() with a time value as parameter. The time
       syntax is based upon the syntax defined in ISO 8601.
       (e.g. time.Now() )
     indefinite: The begin of the animation will be determined by a beginElement() method call or a hyperlink
       targeted to the element.
       (e.g. "infinite")

The attribute value is a semicolon separated list of values. The interpretation of a list of start times is detailed in the SMIL specification in "Evaluation of begin and end time lists". Each individual value can be one of the following: <offset-value>, <syncbase-value>, <event-value>, <repeat-value>, <accessKey-value>, <wallclock-sync-value> or the keyword 'indefinite'.

Português: 

O atributo begin define quando uma animação deve começar ou quando um elemento deve ser descartado.

 Entrada:
   begin: define quando uma animação deve começar ou quando um elemento deve ser descartado.
     offset-value: Esse valor define um valor de relógio que representa um ponto no tempo relativo ao início do
       documento SVG (geralmente o evento load ou DOMContentLoaded). Valores negativos são válidos.
       (e.g. time.Second*5 or "5s")
     syncbase-value: Esse valor define uma base de sincronização e um deslocamento opcional dessa base de
       sincronização. A hora de início da animação do elemento é definida em relação ao início ou fim ativo de outra
       animação.
       Um valor syncbase válido consiste em uma referência de ID para outro elemento de animação seguido por um
       ponto e um início ou fim para identificar se deve ser sincronizado com o início ou o final ativo do elemento
       de animação referenciado. Um valor de deslocamento opcional conforme definido em <offset-value> pode ser
       anexado.
       (e.g. "0s;third.end", "first.end" or "second.end")
     event-value: Esse valor define um evento e um deslocamento opcional que determina a hora em que a animação do
       elemento deve começar. A hora de início da animação é definida em relação à hora em que o evento especificado
       é acionado.
       Um valor de evento válido consiste em um ID de elemento seguido por um ponto e um dos eventos com suporte
       para esse elemento. Todos os eventos válidos (não necessariamente suportados por todos os elementos) são
       definidos pelas especificações DOM e HTML. Esses valores são: 'focus', 'blur', 'focusin', 'focusout',
       'activate', 'auxclick', 'click', 'dblclick', 'mousedown', 'mouseenter', 'mouseleave', 'mousemove',
       'mouseout', 'mouseover', 'mouseup', 'wheel', 'beforeinput', 'input', 'keydown', 'keyup', 'compositionstart',
       'compositionupdate', 'compositionend', 'load', 'unload', 'abort', 'error', 'select', 'resize', 'scroll',
       'beginEvent', 'endEvent', e 'repeatEvent'. Um valor de deslocamento opcional conforme definido em
       <offset-value> pode ser anexado.
       (e.g. "startButton.click")
     repeat-value: Esse valor define um evento de repetição qualificado. A hora de início da animação do elemento é
       definida em relação à hora em que o evento de repetição é gerado com o valor de iteração especificado.
       Um valor de repetição válido consiste em um ID de elemento seguido por um ponto e a função repeat() com um
       valor inteiro especificando o número de repetições como parâmetro. Um valor de deslocamento opcional conforme
       definido em <offset-value> pode ser anexado.
       (e.g. "0s;myLoop.end", "myLoop.begin", "myLoop.repeat(1)" or "myLoop.repeat(2)")
     accessKey-value: Este valor define uma chave de acesso que deve acionar a animação. A animação do elemento
       começará quando o usuário pressionar a tecla especificada.
       Um valor válido de accessKey consiste na função accessKey() com o caractere a ser inserido como parâmetro.
       Um valor de deslocamento opcional conforme definido em <valor de deslocamento> pode ser anexado.
       (e.g. "accessKey(s)")
     wallclock-sync-value: Esse valor define a hora de início da animação como uma hora do relógio do mundo real.
       Um valor wallclock-sync válido consiste na função wallclock() com um valor de tempo como parâmetro. A sintaxe
       de tempo é baseada na sintaxe definida na ISO 8601.
       (e.g. time.Now() )
     indefinite: O início da animação será determinado por uma chamada de método beginElement() ou um hiperlink
       direcionado ao elemento.
       (e.g. "infinite")

O valor do atributo é uma lista de valores separados por ponto e vírgula. A interpretação de uma lista de horários de início é detalhada na especificação SMIL em "Avaliação de listas de horários de início e término". Cada valor individual pode ser um dos seguintes: <offset-value>, <syncbase-value>, <event-value>, <repeat-value>, <accessKey-value>, <wallclock-sync-value> ou a palavra-chave 'indefinite'.

func (*TagSvgAnimate) By 

func (e *TagSvgAnimate) By(by float64) (ref *TagSvgAnimate)

By

English: 

The by attribute specifies a relative offset value for an attribute that will be modified during an animation.

 Input:
   by: specifies a relative offset value for an attribute

The starting value for the attribute is either indicated by specifying it as value for the attribute given in the attributeName or the from attribute.

Português: 

O atributo by especifica um valor de deslocamento relativo para um atributo que será modificado durante uma
animação.

 Entrada:
   by: especifica um valor de deslocamento relativo para um atributo

O valor inicial para o atributo é indicado especificando-o como valor para o atributo fornecido no attributeName ou no atributo from.

func (*TagSvgAnimate) CalcMode 

func (e *TagSvgAnimate) CalcMode(value interface{}) (ref *TagSvgAnimate)

CalcMode

English: 

The calcMode attribute specifies the interpolation mode for the animation.

 Input:
   KSvgCalcModeDiscrete: This specifies that the animation function will jump from one value to the next without
     any interpolation.
   KSvgCalcModeLinear: Simple linear interpolation between values is used to calculate the animation function.
     Except for <animateMotion>, this is the default value.
   KSvgCalcModePaced: Defines interpolation to produce an even pace of change across the animation.
   KSvgCalcModeSpline: Interpolates from one value in the values list to the next according to a time function
     defined by a cubic Bézier spline. The points of the spline are defined in the keyTimes attribute, and the
     control points for each interval are defined in the keySplines attribute.

The default mode is linear, however if the attribute does not support linear interpolation (e.g. for strings), the calcMode attribute is ignored and discrete interpolation is used. 

Notes:
  Default value: KSvgCalcModePaced

Português: 

O atributo calcMode especifica o modo de interpolação para a animação.

 Entrada:
   KSvgCalcModeDiscrete: Isso especifica que a função de animação saltará de um valor para o próximo sem qualquer
     interpolação.
   KSvgCalcModeLinear: A interpolação linear simples entre valores é usada para calcular a função de animação.
     Exceto para <animateMotion>, este é o valor padrão.
   KSvgCalcModePaced: Define a interpolação para produzir um ritmo uniforme de mudança na animação.
   KSvgCalcModeSpline: Interpola de um valor na lista de valores para o próximo de acordo com uma função de tempo
     definida por uma spline de Bézier cúbica. Os pontos do spline são definidos no atributo keyTimes e os pontos
     de controle para cada intervalo são definidos no atributo keySplines.

O modo padrão é linear, no entanto, se o atributo não suportar interpolação linear (por exemplo, para strings), o atributo calcMode será ignorado e a interpolação discreta será usada. 

Notas:
  * Valor padrão: KSvgCalcModePaced

func (*TagSvgAnimate) Class 

func (e *TagSvgAnimate) Class(class string) (ref *TagSvgAnimate)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgAnimate) CreateElement 

func (e *TagSvgAnimate) CreateElement() (ref *TagSvgAnimate)

func (*TagSvgAnimate) Dur 

func (e *TagSvgAnimate) Dur(dur interface{}) (ref *TagSvgAnimate)

Dur

English: 

The dur attribute indicates the simple duration of an animation.

 Input:
   dur: indicates the simple duration of an animation.
     KSvgDur... (e.g. KSvgDurIndefinite)
     time.Duration (e.g. time.Second * 5)

 Notes:
   * The interpolation will not work if the simple duration is indefinite (although this may still be useful for
     <set> elements).

Português: 

O atributo dur indica a duração simples de uma animação.

 Entrada:
   dur: indica a duração simples de uma animação.
     KSvgDur... (ex. KSvgDurIndefinite)
     time.Duration (ex. time.Second * 5)

 Notas:
   * A interpolação não funcionará se a duração simples for indefinida (embora isso ainda possa ser útil para
     elementos <set>).

func (*TagSvgAnimate) End 

func (e *TagSvgAnimate) End(end interface{}) (ref *TagSvgAnimate)

End

English: 

The end attribute defines an end value for the animation that can constrain the active duration.

 Input:
   end: defines an end value for the animation
     offset-value: This value defines a clock-value that represents a point in time relative to the beginning of the
       SVG document (usually the load or DOMContentLoaded event). Negative values are valid.
       (e.g. time.Second*5 or "5s")
     syncbase-value: This value defines a syncbase and an optional offset from that syncbase. The element's
       animation start time is defined relative to the begin or active end of another animation.
       A valid syncbase-value consists of an ID reference to another animation element followed by a dot and either
       begin or end to identify whether to synchronize with the beginning or active end of the referenced animation
       element. An optional offset value as defined in <offset-value> can be appended.
       (e.g. "0s;third.end", "first.end" or "second.end")
     event-value: This value defines an event and an optional offset that determines the time at which the element's
       animation should begin. The animation start time is defined relative to the time that the specified event is
       fired.
       A valid event-value consists of an element ID followed by a dot and one of the supported events for that
       element. All valid events (not necessarily supported by all elements) are defined by the DOM and HTML
       specifications. Those are: 'focus', 'blur', 'focusin', 'focusout', 'activate', 'auxclick', 'click',
       'dblclick', 'mousedown', 'mouseenter', 'mouseleave', 'mousemove', 'mouseout', 'mouseover', 'mouseup',
       'wheel', 'beforeinput', 'input', 'keydown', 'keyup', 'compositionstart', 'compositionupdate',
       'compositionend', 'load', 'unload', 'abort', 'error', 'select', 'resize', 'scroll', 'beginEvent', 'endEvent',
       and 'repeatEvent'. An optional offset value as defined in <offset-value> can be appended.
       (e.g. "startButton.click")
     repeat-value: This value defines a qualified repeat event. The element animation start time is defined relative
       to the time that the repeat event is raised with the specified iteration value.
       A valid repeat value consists of an element ID followed by a dot and the function repeat() with an integer
       value specifying the number of repetitions as parameter. An optional offset value as defined in
       <offset-value> can be appended.
       (e.g. "0s;myLoop.end", "myLoop.begin", "myLoop.repeat(1)" or "myLoop.repeat(2)")
     accessKey-value: This value defines an access key that should trigger the animation. The element animation will
       begin when the user presses the specified key.
       A valid accessKey-value consists of the function accessKey() with the character to be input as parameter. An
       optional offset value as defined in <offset-value> can be appended.
       (e.g. "accessKey(s)")
     wallclock-sync-value: This value defines the animation start time as a real-world clock time.
       A valid wallclock-sync-value consists of the function wallclock() with a time value as parameter. The time
       syntax is based upon the syntax defined in ISO 8601.
       (e.g. time.Now() )
     indefinite: The begin of the animation will be determined by a beginElement() method call or a hyperlink
       targeted to the element.
       (e.g. "infinite")

Portuguese 

O atributo final define um valor final para a animação que pode restringir a duração ativa.

 Entrada:
   end: define um valor final para a animação
     offset-value: Esse valor define um valor de relógio que representa um ponto no tempo relativo ao início do
       documento SVG (geralmente o evento load ou DOMContentLoaded). Valores negativos são válidos.
       (e.g. time.Second*5 or "5s")
     syncbase-value: Esse valor define uma base de sincronização e um deslocamento opcional dessa base de
       sincronização. A hora de início da animação do elemento é definida em relação ao início ou fim ativo de outra
       animação.
       Um valor syncbase válido consiste em uma referência de ID para outro elemento de animação seguido por um
       ponto e um início ou fim para identificar se deve ser sincronizado com o início ou o final ativo do elemento
       de animação referenciado. Um valor de deslocamento opcional conforme definido em <offset-value> pode ser
       anexado.
       (e.g. "0s;third.end", "first.end" or "second.end")
     event-value: Esse valor define um evento e um deslocamento opcional que determina a hora em que a animação do
       elemento deve começar. A hora de início da animação é definida em relação à hora em que o evento especificado
       é acionado.
       Um valor de evento válido consiste em um ID de elemento seguido por um ponto e um dos eventos com suporte
       para esse elemento. Todos os eventos válidos (não necessariamente suportados por todos os elementos) são
       definidos pelas especificações DOM e HTML. Esses valores são: 'focus', 'blur', 'focusin', 'focusout',
       'activate', 'auxclick', 'click', 'dblclick', 'mousedown', 'mouseenter', 'mouseleave', 'mousemove',
       'mouseout', 'mouseover', 'mouseup', 'wheel', 'beforeinput', 'input', 'keydown', 'keyup', 'compositionstart',
       'compositionupdate', 'compositionend', 'load', 'unload', 'abort', 'error', 'select', 'resize', 'scroll',
       'beginEvent', 'endEvent', e 'repeatEvent'. Um valor de deslocamento opcional conforme definido em
       <offset-value> pode ser anexado.
       (e.g. "startButton.click")
     repeat-value: Esse valor define um evento de repetição qualificado. A hora de início da animação do elemento é
       definida em relação à hora em que o evento de repetição é gerado com o valor de iteração especificado.
       Um valor de repetição válido consiste em um ID de elemento seguido por um ponto e a função repeat() com um
       valor inteiro especificando o número de repetições como parâmetro. Um valor de deslocamento opcional conforme
       definido em <offset-value> pode ser anexado.
       (e.g. "0s;myLoop.end", "myLoop.begin", "myLoop.repeat(1)" or "myLoop.repeat(2)")
     accessKey-value: Este valor define uma chave de acesso que deve acionar a animação. A animação do elemento
       começará quando o usuário pressionar a tecla especificada.
       Um valor válido de accessKey consiste na função accessKey() com o caractere a ser inserido como parâmetro.
       Um valor de deslocamento opcional conforme definido em <valor de deslocamento> pode ser anexado.
       (e.g. "accessKey(s)")
     wallclock-sync-value: Esse valor define a hora de início da animação como uma hora do relógio do mundo real.
       Um valor wallclock-sync válido consiste na função wallclock() com um valor de tempo como parâmetro. A sintaxe
       de tempo é baseada na sintaxe definida na ISO 8601.
       (e.g. time.Now() )
     indefinite: O início da animação será determinado por uma chamada de método beginElement() ou um hiperlink
       direcionado ao elemento.
       (e.g. "infinite")

func (*TagSvgAnimate) Fill 

func (e *TagSvgAnimate) Fill(value interface{}) (ref *TagSvgAnimate)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgAnimate) From 

func (e *TagSvgAnimate) From(value interface{}) (ref *TagSvgAnimate)

From

English:

The from attribute indicates the initial value of the attribute that will be modified during the animation. 

Input:
  value: initial value of the attribute
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1),rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0%, 10%"
    []float64: []float64{0.0, 10.0} = "0, 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s, 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    any other type: interface{}

When used with the to attribute, the animation will change the modified attribute from the from value to the to value. When used with the by attribute, the animation will change the attribute relatively from the from value by the value specified in by.

Português:

O atributo from indica o valor inicial do atributo que será modificado durante a animação. 

Entrada:
  value: valor inicial do atributo
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1),rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0%, 10%"
    []float64: []float64{0.0, 10.0} = "0, 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s, 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    qualquer outro tipo: interface{}

Quando usado com o atributo to, a animação mudará o atributo modificado do valor from para o valor to. Quando usado com o atributo by, a animação mudará o atributo relativamente do valor from pelo valor especificado em by.

func (*TagSvgAnimate) Get 

func (e *TagSvgAnimate) Get() (el js.Value)

func (*TagSvgAnimate) HRef 

func (e *TagSvgAnimate) HRef(href string) (ref *TagSvgAnimate)

HRef

English: 

The href attribute defines a link to a resource as a reference URL. The exact meaning of that link depends on the
context of each element using it.

 Notes:
   * Specifications before SVG 2 defined an xlink:href attribute, which is now rendered obsolete by the href
     attribute.
     If you need to support earlier browser versions, the deprecated xlink:href attribute can be used as a fallback
     in addition to the href attribute, e.g. <use href="some-id" xlink:href="some-id x="5" y="5" />.

Português: 

O atributo href define um link para um recurso como um URL de referência. O significado exato desse link depende do
contexto de cada elemento que o utiliza.

 Notas:
   * As especificações anteriores ao SVG 2 definiam um atributo xlink:href, que agora se torna obsoleto pelo
     atributo href.
     Se você precisar oferecer suporte a versões anteriores do navegador, o atributo obsoleto xlink:href pode ser
     usado como um substituto além do atributo href, por exemplo,
     <use href="some-id" xlink:href="some-id x="5" y="5" />.

func (*TagSvgAnimate) Html 

func (e *TagSvgAnimate) Html(value string) (ref *TagSvgAnimate)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgAnimate) Id 

func (e *TagSvgAnimate) Id(id string) (ref *TagSvgAnimate)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgAnimate) Init 

func (e *TagSvgAnimate) Init() (ref *TagSvgAnimate)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgAnimate) KeySplines 

func (e *TagSvgAnimate) KeySplines(value interface{}) (ref *TagSvgAnimate)

KeySplines

English:

The keySplines attribute defines a set of Bézier curve control points associated with the keyTimes list, defining a cubic Bézier function that controls interval pacing.

This attribute is ignored unless the calcMode attribute is set to spline.

If there are any errors in the keySplines specification (bad values, too many or too few values), the animation will not occur.

Português:

O atributo keySplines define um conjunto de pontos de controle da curva Bézier associados à lista keyTimes, definindo uma função Bézier cúbica que controla o ritmo do intervalo.

Esse atributo é ignorado, a menos que o atributo calcMode seja definido como spline.

Se houver algum erro na especificação de keySplines (valores incorretos, muitos ou poucos valores), a animação não ocorrerá.

func (*TagSvgAnimate) KeyTimes 

func (e *TagSvgAnimate) KeyTimes(value interface{}) (ref *TagSvgAnimate)

KeyTimes

English:

The keyTimes attribute represents a list of time values used to control the pacing of the animation. 

Input:
  value: list of time values used to control
    []float64{0.0, 0.5, 1.0}: values="0; 0.5; 1"

Each time in the list corresponds to a value in the values attribute list, and defines when the value is used in the animation.

Each time value in the keyTimes list is specified as a floating point value between 0 and 1 (inclusive), representing a proportional offset into the duration of the animation element.

Português:

O atributo keyTimes representa uma lista de valores de tempo usados para controlar o ritmo da animação. 

Entrada:
  value: lista de valores de tempo usados para controle
    []float64{0.0, 0.5, 1.0}: values="0; 0.5; 1"

Cada vez na lista corresponde a um valor na lista de atributos de valores e define quando o valor é usado na animação.

Cada valor de tempo na lista keyTimes é especificado como um valor de ponto flutuante entre 0 e 1 (inclusive), representando um deslocamento proporcional à duração do elemento de animação.

func (*TagSvgAnimate) Lang 

func (e *TagSvgAnimate) Lang(value interface{}) (ref *TagSvgAnimate)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgAnimate) Max 

func (e *TagSvgAnimate) Max(value interface{}) (ref *TagSvgAnimate)

Max

English:

The max attribute specifies the maximum value of the active animation duration. 

Input:
  value: specifies the maximum value
    float32: 1.0 = "100%"
    time.Duration: 5*time.Second = "5s"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo max especifica o valor máximo da duração da animação ativa. 

Entrada:
  value: especifica o valor máximo
    float32: 1.0 = "100%"
    time.Duration: 5*time.Second = "5s"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgAnimate) Min 

func (e *TagSvgAnimate) Min(value interface{}) (ref *TagSvgAnimate)

Min

English:

The min attribute specifies the minimum value of the active animation duration. 

Input:
  value: specifies the minimum value
    float32: 1.0 = "100%"
    time.Duration: 5*time.Second = "5s"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo min especifica o valor mínimo da duração da animação ativa. 

Input:
  value: especifica o valor mínimo
    float32: 1.0 = "100%"
    time.Duration: 5*time.Second = "5s"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgAnimate) RepeatCount 

func (e *TagSvgAnimate) RepeatCount(value interface{}) (ref *TagSvgAnimate)

RepeatCount

English:

The repeatCount attribute indicates the number of times an animation will take place. 

Input:
  value: indicates the number of times an animation will take place
    int: number of times
    const: KSvgDurIndefinite
    any other type: interface{}

Português:

O atributo repeatCount indica o número de vezes que uma animação ocorrerá. 

Input:
  value: indica o número de vezes que uma animação ocorrerá
    int: número de vezes
    const: KSvgDurIndefinite
    qualquer outro tipo: interface{}

func (*TagSvgAnimate) RepeatDur 

func (e *TagSvgAnimate) RepeatDur(value interface{}) (ref *TagSvgAnimate)

RepeatDur

English:

The repeatDur attribute specifies the total duration for repeating an animation. 

Input:
  value: specifies the total duration for repeating an animation
    string: "5s"
    time.Duration: 5*time.Second = "5s"
    const: KSvgDurIndefinite
    any other type: interface{}

Português:

O atributo repeatDur especifica a duração total para repetir uma animação. 

Entrada:
  value: especifica a duração total para repetir uma animação
    string: "5s"
    time.Duration: 5*time.Second = "5s"
    const: KSvgDurIndefinite
    qualquer outro tipo: interface{}

func (*TagSvgAnimate) Restart 

func (e *TagSvgAnimate) Restart(value interface{}) (ref *TagSvgAnimate)

Restart

English:

The restart attribute specifies whether or not an animation can restart. 

Input:
  value: especifica se uma animação pode ou não reiniciar
    const: KSvgAnimationRestart... (e.g. KSvgAnimationRestartAlways)
    any other type: interface{}

Português:

O atributo restart especifica se uma animação pode ou não reiniciar. 

Entrada:
  value: especifica se uma animação pode ou não reiniciar
    const: KSvgAnimationRestart... (ex. KSvgAnimationRestartAlways)
    qualquer outro tipo: interface{}

func (*TagSvgAnimate) Style 

func (e *TagSvgAnimate) Style(value string) (ref *TagSvgAnimate)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgAnimate) Tabindex 

func (e *TagSvgAnimate) Tabindex(value int) (ref *TagSvgAnimate)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgAnimate) Text 

func (e *TagSvgAnimate) Text(value string) (ref *TagSvgAnimate)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgAnimate) To 

func (e *TagSvgAnimate) To(value interface{}) (ref *TagSvgAnimate)

To

English:

The to attribute indicates the final value of the attribute that will be modified during the animation. 

Input:
  value: final value of the attribute
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1),rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0%, 10%"
    []float64: []float64{0.0, 10.0} = "0, 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s, 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    any other type: interface{}

The value of the attribute will change between the from attribute value and this value.

Português:

O atributo to indica o valor final do atributo que será modificado durante a animação. 

Entrada:
  value: valor final do atributo
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1),rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0%, 10%"
    []float64: []float64{0.0, 10.0} = "0, 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s, 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    qualquer outro tipo: interface{}

O valor do atributo mudará entre o valor do atributo from e este valor.

func (*TagSvgAnimate) Values 

func (e *TagSvgAnimate) Values(value interface{}) (ref *TagSvgAnimate)

Values

English:

The values attribute has different meanings, depending upon the context where it's used, either it defines a sequence of values used over the course of an animation, or it's a list of numbers for a color matrix, which is interpreted differently depending on the type of color change to be performed. 

Input:
  value: list of values
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1),rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0%, 10%"
    []float64: []float64{0.0, 10.0} = "0, 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s, 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    any other type: interface{}

Português:

O atributo values tem significados diferentes, dependendo do contexto em que é usado, ou define uma sequência de valores usados ao longo de uma animação, ou é uma lista de números para uma matriz de cores, que é interpretada de forma diferente dependendo do tipo de mudança de cor a ser executada. 

Input:
  value: lista de valores
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1),rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0%, 10%"
    []float64: []float64{0.0, 10.0} = "0, 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s, 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    any other type: interface{}

func (*TagSvgAnimate) XLinkHRef deprecated 

func (e *TagSvgAnimate) XLinkHRef(value interface{}) (ref *TagSvgAnimate)

XLinkHRef

English:

Deprecated: use HRef() function

The xlink:href attribute defines a reference to a resource as a reference IRI. The exact meaning of that link depends on the context of each element using it. 

Notes:
  * SVG 2 removed the need for the xlink namespace, so instead of xlink:href you should use href. If you need to
    support earlier browser versions, the deprecated xlink:href attribute can be used as a fallback in addition to
    the href attribute, e.g. <use href="some-id" xlink:href="some-id" x="5" y="5" />.

Português:

Obsoleto: use a função HRef()

O atributo xlink:href define uma referência a um recurso como um IRI de referência. O significado exato desse link depende do contexto de cada elemento que o utiliza. 

Notas:
  * O SVG 2 removeu a necessidade do namespace xlink, então ao invés de xlink:href você deve usar href. Se você
    precisar oferecer suporte a versões anteriores do navegador, o atributo obsoleto xlink:href pode ser usado como
    um substituto além do atributo href, por exemplo, <use href="some-id" xlink:href="some-id" x="5" y="5" >.

func (*TagSvgAnimate) XmlLang 

func (e *TagSvgAnimate) XmlLang(value interface{}) (ref *TagSvgAnimate)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

type TagSvgAnimateMotion 

type TagSvgAnimateMotion struct {
	// contains filtered or unexported fields
}

TagSvgAnimateMotion

English:

The SVG <animateMotion> element provides a way to define how an element moves along a motion path. 

Notes:
  * To reuse an existing path, it will be necessary to use an <mpath> element inside the <animateMotion> element
    instead of the path attribute.

Português:

O elemento SVG <animateMotion> fornece uma maneira de definir como um elemento se move ao longo de um caminho de movimento. 

Notas:
  * Para reutilizar um caminho existente, será necessário usar um elemento <mpath> dentro do elemento
    <animateMotion> ao invés do atributo path.

func (*TagSvgAnimateMotion) Accumulate 

func (e *TagSvgAnimateMotion) Accumulate(value interface{}) (ref *TagSvgAnimateMotion)

Accumulate

English: 

The accumulate attribute controls whether or not an animation is cumulative.

 Input:
   value: controls whether or not an animation is cumulative
     const: KSvgAccumulate... (e.g. KSvgAccumulateSum)
     any other type: interface{}

It is frequently useful for repeated animations to build upon the previous results, accumulating with each iteration. This attribute said to the animation if the value is added to the previous animated attribute's value on each iteration. 

Notes:
  * This attribute is ignored if the target attribute value does not support addition, or if the animation element
    does not repeat;
  * This attribute will be ignored if the animation function is specified with only the to attribute.

Português: 

O atributo acumular controla se uma animação é cumulativa ou não.

 Entrada:
   value: controla se uma animação é cumulativa ou não
     const: KSvgAccumulate... (ex. KSvgAccumulateSum)
     qualquer outro tipo: interface{}

Frequentemente, é útil que as animações repetidas se baseiem nos resultados anteriores, acumulando a cada iteração. Este atributo é dito à animação se o valor for adicionado ao valor do atributo animado anterior em cada iteração. 

Notas:
  * Esse atributo será ignorado se o valor do atributo de destino não suportar adição ou se o elemento de animação
    não se repetir;
  * Este atributo será ignorado se a função de animação for especificada apenas com o atributo to.

func (*TagSvgAnimateMotion) Additive 

func (e *TagSvgAnimateMotion) Additive(value interface{}) (ref *TagSvgAnimateMotion)

Additive

English: 

The additive attribute controls whether or not an animation is additive.

 Input:
   value: controls whether or not an animation is additive
     const: KSvgAdditive... (e.g. KSvgAdditiveSum)
     any other type: interface{}

It is frequently useful to define animation as an offset or delta to an attribute's value, rather than as absolute values.

Português: 

O atributo aditivo controla se uma animação é ou não aditiva.

 Entrada:
   value: controla se uma animação é aditiva ou não
     const: KSvgAdditive... (ex. KSvgAdditiveSum)
     qualquer outro tipo: interface{}

É frequentemente útil definir a animação como um deslocamento ou delta para o valor de um atributo, em vez de valores absolutos.

func (*TagSvgAnimateMotion) Append 

func (e *TagSvgAnimateMotion) Append(elements ...Compatible) (ref *TagSvgAnimateMotion)

func (*TagSvgAnimateMotion) AppendById 

func (e *TagSvgAnimateMotion) AppendById(appendId string) (ref *TagSvgAnimateMotion)

func (*TagSvgAnimateMotion) AppendToElement 

func (e *TagSvgAnimateMotion) AppendToElement(el js.Value) (ref *TagSvgAnimateMotion)

func (*TagSvgAnimateMotion) AppendToStage 

func (e *TagSvgAnimateMotion) AppendToStage() (ref *TagSvgAnimateMotion)

func (*TagSvgAnimateMotion) AttributeName 

func (e *TagSvgAnimateMotion) AttributeName(attributeName string) (ref *TagSvgAnimateMotion)

AttributeName

English: 

The attributeName attribute indicates the name of the CSS property or attribute of the target element that is going
to be changed during an animation.

Português: 

O atributo attributeName indica o nome da propriedade CSS ou atributo do elemento de destino que será alterado
durante uma animação.

func (*TagSvgAnimateMotion) BaselineShift 

func (e *TagSvgAnimateMotion) BaselineShift(baselineShift interface{}) (ref *TagSvgAnimateMotion)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgAnimateMotion) Begin 

func (e *TagSvgAnimateMotion) Begin(begin interface{}) (ref *TagSvgAnimateMotion)

Begin

English: 

The begin attribute defines when an animation should begin or when an element should be discarded.

 Input:
   begin: defines when an animation should begin or when an element should be discarded.
     offset-value: This value defines a clock-value that represents a point in time relative to the beginning of the
       SVG document (usually the load or DOMContentLoaded event). Negative values are valid.
       (e.g. time.Second*5 or "5s")
     syncbase-value: This value defines a syncbase and an optional offset from that syncbase. The element's
       animation start time is defined relative to the begin or active end of another animation.
       A valid syncbase-value consists of an ID reference to another animation element followed by a dot and either
       begin or end to identify whether to synchronize with the beginning or active end of the referenced animation
       element. An optional offset value as defined in <offset-value> can be appended.
       (e.g. "0s;third.end", "first.end" or "second.end")
     event-value: This value defines an event and an optional offset that determines the time at which the element's
       animation should begin. The animation start time is defined relative to the time that the specified event is
       fired.
       A valid event-value consists of an element ID followed by a dot and one of the supported events for that
       element. All valid events (not necessarily supported by all elements) are defined by the DOM and HTML
       specifications. Those are: 'focus', 'blur', 'focusin', 'focusout', 'activate', 'auxclick', 'click',
       'dblclick', 'mousedown', 'mouseenter', 'mouseleave', 'mousemove', 'mouseout', 'mouseover', 'mouseup',
       'wheel', 'beforeinput', 'input', 'keydown', 'keyup', 'compositionstart', 'compositionupdate',
       'compositionend', 'load', 'unload', 'abort', 'error', 'select', 'resize', 'scroll', 'beginEvent', 'endEvent',
       and 'repeatEvent'. An optional offset value as defined in <offset-value> can be appended.
       (e.g. "startButton.click")
     repeat-value: This value defines a qualified repeat event. The element animation start time is defined relative
       to the time that the repeat event is raised with the specified iteration value.
       A valid repeat value consists of an element ID followed by a dot and the function repeat() with an integer
       value specifying the number of repetitions as parameter. An optional offset value as defined in
       <offset-value> can be appended.
       (e.g. "0s;myLoop.end", "myLoop.begin", "myLoop.repeat(1)" or "myLoop.repeat(2)")
     accessKey-value: This value defines an access key that should trigger the animation. The element animation will
       begin when the user presses the specified key.
       A valid accessKey-value consists of the function accessKey() with the character to be input as parameter. An
       optional offset value as defined in <offset-value> can be appended.
       (e.g. "accessKey(s)")
     wallclock-sync-value: This value defines the animation start time as a real-world clock time.
       A valid wallclock-sync-value consists of the function wallclock() with a time value as parameter. The time
       syntax is based upon the syntax defined in ISO 8601.
       (e.g. time.Now() )
     indefinite: The begin of the animation will be determined by a beginElement() method call or a hyperlink
       targeted to the element.
       (e.g. "infinite")

The attribute value is a semicolon separated list of values. The interpretation of a list of start times is detailed in the SMIL specification in "Evaluation of begin and end time lists". Each individual value can be one of the following: <offset-value>, <syncbase-value>, <event-value>, <repeat-value>, <accessKey-value>, <wallclock-sync-value> or the keyword 'indefinite'.

Português: 

O atributo begin define quando uma animação deve começar ou quando um elemento deve ser descartado.

 Entrada:
   begin: define quando uma animação deve começar ou quando um elemento deve ser descartado.
     offset-value: Esse valor define um valor de relógio que representa um ponto no tempo relativo ao início do
       documento SVG (geralmente o evento load ou DOMContentLoaded). Valores negativos são válidos.
       (e.g. time.Second*5 or "5s")
     syncbase-value: Esse valor define uma base de sincronização e um deslocamento opcional dessa base de
       sincronização. A hora de início da animação do elemento é definida em relação ao início ou fim ativo de outra
       animação.
       Um valor syncbase válido consiste em uma referência de ID para outro elemento de animação seguido por um
       ponto e um início ou fim para identificar se deve ser sincronizado com o início ou o final ativo do elemento
       de animação referenciado. Um valor de deslocamento opcional conforme definido em <offset-value> pode ser
       anexado.
       (e.g. "0s;third.end", "first.end" or "second.end")
     event-value: Esse valor define um evento e um deslocamento opcional que determina a hora em que a animação do
       elemento deve começar. A hora de início da animação é definida em relação à hora em que o evento especificado
       é acionado.
       Um valor de evento válido consiste em um ID de elemento seguido por um ponto e um dos eventos com suporte
       para esse elemento. Todos os eventos válidos (não necessariamente suportados por todos os elementos) são
       definidos pelas especificações DOM e HTML. Esses valores são: 'focus', 'blur', 'focusin', 'focusout',
       'activate', 'auxclick', 'click', 'dblclick', 'mousedown', 'mouseenter', 'mouseleave', 'mousemove',
       'mouseout', 'mouseover', 'mouseup', 'wheel', 'beforeinput', 'input', 'keydown', 'keyup', 'compositionstart',
       'compositionupdate', 'compositionend', 'load', 'unload', 'abort', 'error', 'select', 'resize', 'scroll',
       'beginEvent', 'endEvent', e 'repeatEvent'. Um valor de deslocamento opcional conforme definido em
       <offset-value> pode ser anexado.
       (e.g. "startButton.click")
     repeat-value: Esse valor define um evento de repetição qualificado. A hora de início da animação do elemento é
       definida em relação à hora em que o evento de repetição é gerado com o valor de iteração especificado.
       Um valor de repetição válido consiste em um ID de elemento seguido por um ponto e a função repeat() com um
       valor inteiro especificando o número de repetições como parâmetro. Um valor de deslocamento opcional conforme
       definido em <offset-value> pode ser anexado.
       (e.g. "0s;myLoop.end", "myLoop.begin", "myLoop.repeat(1)" or "myLoop.repeat(2)")
     accessKey-value: Este valor define uma chave de acesso que deve acionar a animação. A animação do elemento
       começará quando o usuário pressionar a tecla especificada.
       Um valor válido de accessKey consiste na função accessKey() com o caractere a ser inserido como parâmetro.
       Um valor de deslocamento opcional conforme definido em <valor de deslocamento> pode ser anexado.
       (e.g. "accessKey(s)")
     wallclock-sync-value: Esse valor define a hora de início da animação como uma hora do relógio do mundo real.
       Um valor wallclock-sync válido consiste na função wallclock() com um valor de tempo como parâmetro. A sintaxe
       de tempo é baseada na sintaxe definida na ISO 8601.
       (e.g. time.Now() )
     indefinite: O início da animação será determinado por uma chamada de método beginElement() ou um hiperlink
       direcionado ao elemento.
       (e.g. "infinite")

O valor do atributo é uma lista de valores separados por ponto e vírgula. A interpretação de uma lista de horários de início é detalhada na especificação SMIL em "Avaliação de listas de horários de início e término". Cada valor individual pode ser um dos seguintes: <offset-value>, <syncbase-value>, <event-value>, <repeat-value>, <accessKey-value>, <wallclock-sync-value> ou a palavra-chave 'indefinite'.

func (*TagSvgAnimateMotion) By 

func (e *TagSvgAnimateMotion) By(by float64) (ref *TagSvgAnimateMotion)

By

English: 

The by attribute specifies a relative offset value for an attribute that will be modified during an animation.

 Input:
   by: specifies a relative offset value for an attribute

The starting value for the attribute is either indicated by specifying it as value for the attribute given in the attributeName or the from attribute.

Português: 

O atributo by especifica um valor de deslocamento relativo para um atributo que será modificado durante uma
animação.

 Entrada:
   by: especifica um valor de deslocamento relativo para um atributo

O valor inicial para o atributo é indicado especificando-o como valor para o atributo fornecido no attributeName ou no atributo from.

func (*TagSvgAnimateMotion) CalcMode 

func (e *TagSvgAnimateMotion) CalcMode(value interface{}) (ref *TagSvgAnimateMotion)

CalcMode

English: 

The calcMode attribute specifies the interpolation mode for the animation.

 Input:
   KSvgCalcModeDiscrete: This specifies that the animation function will jump from one value to the next without
     any interpolation.
   KSvgCalcModeLinear: Simple linear interpolation between values is used to calculate the animation function.
     Except for <animateMotion>, this is the default value.
   KSvgCalcModePaced: Defines interpolation to produce an even pace of change across the animation.
   KSvgCalcModeSpline: Interpolates from one value in the values list to the next according to a time function
     defined by a cubic Bézier spline. The points of the spline are defined in the keyTimes attribute, and the
     control points for each interval are defined in the keySplines attribute.

The default mode is linear, however if the attribute does not support linear interpolation (e.g. for strings), the calcMode attribute is ignored and discrete interpolation is used. 

Notes:
  Default value: KSvgCalcModePaced

Português: 

O atributo calcMode especifica o modo de interpolação para a animação.

 Entrada:
   KSvgCalcModeDiscrete: Isso especifica que a função de animação saltará de um valor para o próximo sem qualquer
     interpolação.
   KSvgCalcModeLinear: A interpolação linear simples entre valores é usada para calcular a função de animação.
     Exceto para <animateMotion>, este é o valor padrão.
   KSvgCalcModePaced: Define a interpolação para produzir um ritmo uniforme de mudança na animação.
   KSvgCalcModeSpline: Interpola de um valor na lista de valores para o próximo de acordo com uma função de tempo
     definida por uma spline de Bézier cúbica. Os pontos do spline são definidos no atributo keyTimes e os pontos
     de controle para cada intervalo são definidos no atributo keySplines.

O modo padrão é linear, no entanto, se o atributo não suportar interpolação linear (por exemplo, para strings), o atributo calcMode será ignorado e a interpolação discreta será usada. 

Notas:
  * Valor padrão: KSvgCalcModePaced

func (*TagSvgAnimateMotion) Class 

func (e *TagSvgAnimateMotion) Class(class string) (ref *TagSvgAnimateMotion)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgAnimateMotion) ClipPath 

func (e *TagSvgAnimateMotion) ClipPath(clipPath string) (ref *TagSvgAnimateMotion)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgAnimateMotion) ClipRule 

func (e *TagSvgAnimateMotion) ClipRule(value interface{}) (ref *TagSvgAnimateMotion)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgAnimateMotion) Color 

func (e *TagSvgAnimateMotion) Color(value interface{}) (ref *TagSvgAnimateMotion)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgAnimateMotion) ColorInterpolation 

func (e *TagSvgAnimateMotion) ColorInterpolation(value interface{}) (ref *TagSvgAnimateMotion)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgAnimateMotion) ColorInterpolationFilters 

func (e *TagSvgAnimateMotion) ColorInterpolationFilters(value interface{}) (ref *TagSvgAnimateMotion)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgAnimateMotion) CreateElement 

func (e *TagSvgAnimateMotion) CreateElement() (ref *TagSvgAnimateMotion)

func (*TagSvgAnimateMotion) Cursor 

func (e *TagSvgAnimateMotion) Cursor(cursor SvgCursor) (ref *TagSvgAnimateMotion)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgAnimateMotion) Direction 

func (e *TagSvgAnimateMotion) Direction(direction SvgDirection) (ref *TagSvgAnimateMotion)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgAnimateMotion) Display 

func (e *TagSvgAnimateMotion) Display(value interface{}) (ref *TagSvgAnimateMotion)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgAnimateMotion) DominantBaseline 

func (e *TagSvgAnimateMotion) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgAnimateMotion)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgAnimateMotion) Dur 

func (e *TagSvgAnimateMotion) Dur(dur interface{}) (ref *TagSvgAnimateMotion)

Dur

English: 

The dur attribute indicates the simple duration of an animation.

 Input:
   dur: indicates the simple duration of an animation.
     KSvgDur... (e.g. KSvgDurIndefinite)
     time.Duration (e.g. time.Second * 5)

 Notes:
   * The interpolation will not work if the simple duration is indefinite (although this may still be useful for
     <set> elements).

Português: 

O atributo dur indica a duração simples de uma animação.

 Entrada:
   dur: indica a duração simples de uma animação.
     KSvgDur... (ex. KSvgDurIndefinite)
     time.Duration (ex. time.Second * 5)

 Notas:
   * A interpolação não funcionará se a duração simples for indefinida (embora isso ainda possa ser útil para
     elementos <set>).

func (*TagSvgAnimateMotion) End 

func (e *TagSvgAnimateMotion) End(end interface{}) (ref *TagSvgAnimateMotion)

End

English: 

The end attribute defines an end value for the animation that can constrain the active duration.

 Input:
   end: defines an end value for the animation
     offset-value: This value defines a clock-value that represents a point in time relative to the beginning of the
       SVG document (usually the load or DOMContentLoaded event). Negative values are valid.
       (e.g. time.Second*5 or "5s")
     syncbase-value: This value defines a syncbase and an optional offset from that syncbase. The element's
       animation start time is defined relative to the begin or active end of another animation.
       A valid syncbase-value consists of an ID reference to another animation element followed by a dot and either
       begin or end to identify whether to synchronize with the beginning or active end of the referenced animation
       element. An optional offset value as defined in <offset-value> can be appended.
       (e.g. "0s;third.end", "first.end" or "second.end")
     event-value: This value defines an event and an optional offset that determines the time at which the element's
       animation should begin. The animation start time is defined relative to the time that the specified event is
       fired.
       A valid event-value consists of an element ID followed by a dot and one of the supported events for that
       element. All valid events (not necessarily supported by all elements) are defined by the DOM and HTML
       specifications. Those are: 'focus', 'blur', 'focusin', 'focusout', 'activate', 'auxclick', 'click',
       'dblclick', 'mousedown', 'mouseenter', 'mouseleave', 'mousemove', 'mouseout', 'mouseover', 'mouseup',
       'wheel', 'beforeinput', 'input', 'keydown', 'keyup', 'compositionstart', 'compositionupdate',
       'compositionend', 'load', 'unload', 'abort', 'error', 'select', 'resize', 'scroll', 'beginEvent', 'endEvent',
       and 'repeatEvent'. An optional offset value as defined in <offset-value> can be appended.
       (e.g. "startButton.click")
     repeat-value: This value defines a qualified repeat event. The element animation start time is defined relative
       to the time that the repeat event is raised with the specified iteration value.
       A valid repeat value consists of an element ID followed by a dot and the function repeat() with an integer
       value specifying the number of repetitions as parameter. An optional offset value as defined in
       <offset-value> can be appended.
       (e.g. "0s;myLoop.end", "myLoop.begin", "myLoop.repeat(1)" or "myLoop.repeat(2)")
     accessKey-value: This value defines an access key that should trigger the animation. The element animation will
       begin when the user presses the specified key.
       A valid accessKey-value consists of the function accessKey() with the character to be input as parameter. An
       optional offset value as defined in <offset-value> can be appended.
       (e.g. "accessKey(s)")
     wallclock-sync-value: This value defines the animation start time as a real-world clock time.
       A valid wallclock-sync-value consists of the function wallclock() with a time value as parameter. The time
       syntax is based upon the syntax defined in ISO 8601.
       (e.g. time.Now() )
     indefinite: The begin of the animation will be determined by a beginElement() method call or a hyperlink
       targeted to the element.
       (e.g. "infinite")

Portuguese 

O atributo final define um valor final para a animação que pode restringir a duração ativa.

 Entrada:
   end: define um valor final para a animação
     offset-value: Esse valor define um valor de relógio que representa um ponto no tempo relativo ao início do
       documento SVG (geralmente o evento load ou DOMContentLoaded). Valores negativos são válidos.
       (e.g. time.Second*5 or "5s")
     syncbase-value: Esse valor define uma base de sincronização e um deslocamento opcional dessa base de
       sincronização. A hora de início da animação do elemento é definida em relação ao início ou fim ativo de outra
       animação.
       Um valor syncbase válido consiste em uma referência de ID para outro elemento de animação seguido por um
       ponto e um início ou fim para identificar se deve ser sincronizado com o início ou o final ativo do elemento
       de animação referenciado. Um valor de deslocamento opcional conforme definido em <offset-value> pode ser
       anexado.
       (e.g. "0s;third.end", "first.end" or "second.end")
     event-value: Esse valor define um evento e um deslocamento opcional que determina a hora em que a animação do
       elemento deve começar. A hora de início da animação é definida em relação à hora em que o evento especificado
       é acionado.
       Um valor de evento válido consiste em um ID de elemento seguido por um ponto e um dos eventos com suporte
       para esse elemento. Todos os eventos válidos (não necessariamente suportados por todos os elementos) são
       definidos pelas especificações DOM e HTML. Esses valores são: 'focus', 'blur', 'focusin', 'focusout',
       'activate', 'auxclick', 'click', 'dblclick', 'mousedown', 'mouseenter', 'mouseleave', 'mousemove',
       'mouseout', 'mouseover', 'mouseup', 'wheel', 'beforeinput', 'input', 'keydown', 'keyup', 'compositionstart',
       'compositionupdate', 'compositionend', 'load', 'unload', 'abort', 'error', 'select', 'resize', 'scroll',
       'beginEvent', 'endEvent', e 'repeatEvent'. Um valor de deslocamento opcional conforme definido em
       <offset-value> pode ser anexado.
       (e.g. "startButton.click")
     repeat-value: Esse valor define um evento de repetição qualificado. A hora de início da animação do elemento é
       definida em relação à hora em que o evento de repetição é gerado com o valor de iteração especificado.
       Um valor de repetição válido consiste em um ID de elemento seguido por um ponto e a função repeat() com um
       valor inteiro especificando o número de repetições como parâmetro. Um valor de deslocamento opcional conforme
       definido em <offset-value> pode ser anexado.
       (e.g. "0s;myLoop.end", "myLoop.begin", "myLoop.repeat(1)" or "myLoop.repeat(2)")
     accessKey-value: Este valor define uma chave de acesso que deve acionar a animação. A animação do elemento
       começará quando o usuário pressionar a tecla especificada.
       Um valor válido de accessKey consiste na função accessKey() com o caractere a ser inserido como parâmetro.
       Um valor de deslocamento opcional conforme definido em <valor de deslocamento> pode ser anexado.
       (e.g. "accessKey(s)")
     wallclock-sync-value: Esse valor define a hora de início da animação como uma hora do relógio do mundo real.
       Um valor wallclock-sync válido consiste na função wallclock() com um valor de tempo como parâmetro. A sintaxe
       de tempo é baseada na sintaxe definida na ISO 8601.
       (e.g. time.Now() )
     indefinite: O início da animação será determinado por uma chamada de método beginElement() ou um hiperlink
       direcionado ao elemento.
       (e.g. "infinite")

func (*TagSvgAnimateMotion) Fill 

func (e *TagSvgAnimateMotion) Fill(value interface{}) (ref *TagSvgAnimateMotion)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgAnimateMotion) FillOpacity 

func (e *TagSvgAnimateMotion) FillOpacity(value interface{}) (ref *TagSvgAnimateMotion)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgAnimateMotion) FillRule 

func (e *TagSvgAnimateMotion) FillRule(fillRule SvgFillRule) (ref *TagSvgAnimateMotion)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgAnimateMotion) Filter 

func (e *TagSvgAnimateMotion) Filter(filter string) (ref *TagSvgAnimateMotion)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgAnimateMotion) FloodColor 

func (e *TagSvgAnimateMotion) FloodColor(floodColor interface{}) (ref *TagSvgAnimateMotion)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgAnimateMotion) FloodOpacity 

func (e *TagSvgAnimateMotion) FloodOpacity(floodOpacity float64) (ref *TagSvgAnimateMotion)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgAnimateMotion) FontFamily 

func (e *TagSvgAnimateMotion) FontFamily(fontFamily string) (ref *TagSvgAnimateMotion)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgAnimateMotion) FontSize 

func (e *TagSvgAnimateMotion) FontSize(fontSize interface{}) (ref *TagSvgAnimateMotion)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgAnimateMotion) FontSizeAdjust 

func (e *TagSvgAnimateMotion) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgAnimateMotion)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgAnimateMotion) FontStretch 

func (e *TagSvgAnimateMotion) FontStretch(fontStretch interface{}) (ref *TagSvgAnimateMotion)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgAnimateMotion) FontStyle 

func (e *TagSvgAnimateMotion) FontStyle(fontStyle FontStyleRule) (ref *TagSvgAnimateMotion)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgAnimateMotion) FontVariant 

func (e *TagSvgAnimateMotion) FontVariant(value interface{}) (ref *TagSvgAnimateMotion)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgAnimateMotion) FontWeight 

func (e *TagSvgAnimateMotion) FontWeight(value interface{}) (ref *TagSvgAnimateMotion)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgAnimateMotion) From 

func (e *TagSvgAnimateMotion) From(value interface{}) (ref *TagSvgAnimateMotion)

From

English:

The from attribute indicates the initial value of the attribute that will be modified during the animation. 

Input:
  value: initial value of the attribute
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1),rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0%, 10%"
    []float64: []float64{0.0, 10.0} = "0, 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s, 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    any other type: interface{}

When used with the to attribute, the animation will change the modified attribute from the from value to the to value. When used with the by attribute, the animation will change the attribute relatively from the from value by the value specified in by.

Português:

O atributo from indica o valor inicial do atributo que será modificado durante a animação. 

Entrada:
  value: valor inicial do atributo
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1),rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0%, 10%"
    []float64: []float64{0.0, 10.0} = "0, 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s, 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    qualquer outro tipo: interface{}

Quando usado com o atributo to, a animação mudará o atributo modificado do valor from para o valor to. Quando usado com o atributo by, a animação mudará o atributo relativamente do valor from pelo valor especificado em by.

func (*TagSvgAnimateMotion) Get 

func (e *TagSvgAnimateMotion) Get() (el js.Value)

func (*TagSvgAnimateMotion) HRef 

func (e *TagSvgAnimateMotion) HRef(href string) (ref *TagSvgAnimateMotion)

HRef

English: 

The href attribute defines a link to a resource as a reference URL. The exact meaning of that link depends on the
context of each element using it.

 Notes:
   * Specifications before SVG 2 defined an xlink:href attribute, which is now rendered obsolete by the href
     attribute.
     If you need to support earlier browser versions, the deprecated xlink:href attribute can be used as a fallback
     in addition to the href attribute, e.g. <use href="some-id" xlink:href="some-id x="5" y="5" />.

Português: 

O atributo href define um link para um recurso como um URL de referência. O significado exato desse link depende do
contexto de cada elemento que o utiliza.

 Notas:
   * As especificações anteriores ao SVG 2 definiam um atributo xlink:href, que agora se torna obsoleto pelo
     atributo href.
     Se você precisar oferecer suporte a versões anteriores do navegador, o atributo obsoleto xlink:href pode ser
     usado como um substituto além do atributo href, por exemplo,
     <use href="some-id" xlink:href="some-id x="5" y="5" />.

func (*TagSvgAnimateMotion) Html 

func (e *TagSvgAnimateMotion) Html(value string) (ref *TagSvgAnimateMotion)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgAnimateMotion) Id 

func (e *TagSvgAnimateMotion) Id(id string) (ref *TagSvgAnimateMotion)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgAnimateMotion) ImageRendering 

func (e *TagSvgAnimateMotion) ImageRendering(imageRendering string) (ref *TagSvgAnimateMotion)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgAnimateMotion) Init 

func (e *TagSvgAnimateMotion) Init() (ref *TagSvgAnimateMotion)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgAnimateMotion) KeyPoints 

func (e *TagSvgAnimateMotion) KeyPoints(keyPoints []float64) (ref *TagSvgAnimateMotion)

KeyPoints

English:

The keyPoints attribute indicates the simple duration of an animation. 

Input:
  keyPoints: This value defines a semicolon-separated list of floating point values between 0 and 1 and indicates
  how far along the motion path the object shall move at the moment in time specified by corresponding keyTimes
  value. The distance is calculated along the path specified by the path attribute. Each progress value in the list
  corresponds to a value in the keyTimes attribute list.
  If a list of key points is specified, there must be exactly as many values in the keyPoints list as in the
  keyTimes list.
  If there's a semicolon at the end of the value, optionally followed by white space, both the semicolon and the
  trailing white space are ignored.
  If there are any errors in the value specification (i.e. bad values, too many or too few values), then that's
  an error.

Português:

O atributo keyPoints indica a duração simples de uma animação. 

Entrada:
  keyPoints: Este valor define uma lista separada por ponto e vírgula de valores de ponto flutuante entre 0 e 1 e
  indica a distância ao longo do caminho de movimento o objeto deve se mover no momento especificado pelo valor
  keyTimes correspondente. A distância é calculada ao longo do caminho especificado pelo atributo path. Cada valor
  de progresso na lista corresponde a um valor na lista de atributos keyTimes.
  Se uma lista de pontos-chave for especificada, deve haver exatamente tantos valores na lista keyPoints quanto na
  lista keyTimes.
  Se houver um ponto e vírgula no final do valor, opcionalmente seguido por espaço em branco, o ponto e vírgula e
  o espaço em branco à direita serão ignorados.
  Se houver algum erro na especificação do valor (ou seja, valores incorretos, muitos ou poucos valores), isso é
  um erro.

func (*TagSvgAnimateMotion) KeySplines 

func (e *TagSvgAnimateMotion) KeySplines(value interface{}) (ref *TagSvgAnimateMotion)

KeySplines

English:

The keySplines attribute defines a set of Bézier curve control points associated with the keyTimes list, defining a cubic Bézier function that controls interval pacing.

This attribute is ignored unless the calcMode attribute is set to spline.

If there are any errors in the keySplines specification (bad values, too many or too few values), the animation will not occur.

Português:

O atributo keySplines define um conjunto de pontos de controle da curva Bézier associados à lista keyTimes, definindo uma função Bézier cúbica que controla o ritmo do intervalo.

Esse atributo é ignorado, a menos que o atributo calcMode seja definido como spline.

Se houver algum erro na especificação de keySplines (valores incorretos, muitos ou poucos valores), a animação não ocorrerá.

func (*TagSvgAnimateMotion) KeyTimes 

func (e *TagSvgAnimateMotion) KeyTimes(value interface{}) (ref *TagSvgAnimateMotion)

KeyTimes

English:

The keyTimes attribute represents a list of time values used to control the pacing of the animation. 

Input:
  value: list of time values used to control
    []float64{0.0, 0.5, 1.0}: values="0; 0.5; 1"

Each time in the list corresponds to a value in the values attribute list, and defines when the value is used in the animation.

Each time value in the keyTimes list is specified as a floating point value between 0 and 1 (inclusive), representing a proportional offset into the duration of the animation element.

Português:

O atributo keyTimes representa uma lista de valores de tempo usados para controlar o ritmo da animação. 

Entrada:
  value: lista de valores de tempo usados para controle
    []float64{0.0, 0.5, 1.0}: values="0; 0.5; 1"

Cada vez na lista corresponde a um valor na lista de atributos de valores e define quando o valor é usado na animação.

Cada valor de tempo na lista keyTimes é especificado como um valor de ponto flutuante entre 0 e 1 (inclusive), representando um deslocamento proporcional à duração do elemento de animação.

func (*TagSvgAnimateMotion) Lang 

func (e *TagSvgAnimateMotion) Lang(value interface{}) (ref *TagSvgAnimateMotion)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgAnimateMotion) LetterSpacing 

func (e *TagSvgAnimateMotion) LetterSpacing(value float64) (ref *TagSvgAnimateMotion)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgAnimateMotion) LightingColor 

func (e *TagSvgAnimateMotion) LightingColor(value interface{}) (ref *TagSvgAnimateMotion)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgAnimateMotion) MarkerEnd 

func (e *TagSvgAnimateMotion) MarkerEnd(value interface{}) (ref *TagSvgAnimateMotion)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgAnimateMotion) MarkerMid 

func (e *TagSvgAnimateMotion) MarkerMid(value interface{}) (ref *TagSvgAnimateMotion)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgAnimateMotion) MarkerStart 

func (e *TagSvgAnimateMotion) MarkerStart(value interface{}) (ref *TagSvgAnimateMotion)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgAnimateMotion) Mask 

func (e *TagSvgAnimateMotion) Mask(value interface{}) (ref *TagSvgAnimateMotion)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgAnimateMotion) Max 

func (e *TagSvgAnimateMotion) Max(value interface{}) (ref *TagSvgAnimateMotion)

Max

English:

The max attribute specifies the maximum value of the active animation duration. 

Input:
  value: specifies the maximum value
    float32: 1.0 = "100%"
    time.Duration: 5*time.Second = "5s"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo max especifica o valor máximo da duração da animação ativa. 

Entrada:
  value: especifica o valor máximo
    float32: 1.0 = "100%"
    time.Duration: 5*time.Second = "5s"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgAnimateMotion) Min 

func (e *TagSvgAnimateMotion) Min(value interface{}) (ref *TagSvgAnimateMotion)

Min

English:

The min attribute specifies the minimum value of the active animation duration. 

Input:
  value: specifies the minimum value
    float32: 1.0 = "100%"
    time.Duration: 5*time.Second = "5s"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo min especifica o valor mínimo da duração da animação ativa. 

Input:
  value: especifica o valor mínimo
    float32: 1.0 = "100%"
    time.Duration: 5*time.Second = "5s"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgAnimateMotion) Opacity 

func (e *TagSvgAnimateMotion) Opacity(value interface{}) (ref *TagSvgAnimateMotion)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgAnimateMotion) Overflow 

func (e *TagSvgAnimateMotion) Overflow(value interface{}) (ref *TagSvgAnimateMotion)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgAnimateMotion) Path 

func (e *TagSvgAnimateMotion) Path(value *SvgPath) (ref *TagSvgAnimateMotion)

Path

English:

The path attribute has two different meanings, either it defines a text path along which the characters of a text are rendered, or a motion path along which a referenced element is animated.

Português:

O atributo path tem dois significados diferentes: define um caminho de texto ao longo do qual os caracteres de um texto são renderizados ou um caminho de movimento ao longo do qual um elemento referenciado é animado.

func (*TagSvgAnimateMotion) PointerEvents 

func (e *TagSvgAnimateMotion) PointerEvents(value interface{}) (ref *TagSvgAnimateMotion)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgAnimateMotion) RepeatCount 

func (e *TagSvgAnimateMotion) RepeatCount(value interface{}) (ref *TagSvgAnimateMotion)

RepeatCount

English:

The repeatCount attribute indicates the number of times an animation will take place. 

Input:
  value: indicates the number of times an animation will take place
    int: number of times
    const: KSvgDurIndefinite
    any other type: interface{}

Português:

O atributo repeatCount indica o número de vezes que uma animação ocorrerá. 

Input:
  value: indica o número de vezes que uma animação ocorrerá
    int: número de vezes
    const: KSvgDurIndefinite
    qualquer outro tipo: interface{}

func (*TagSvgAnimateMotion) RepeatDur 

func (e *TagSvgAnimateMotion) RepeatDur(value interface{}) (ref *TagSvgAnimateMotion)

RepeatDur

English:

The repeatDur attribute specifies the total duration for repeating an animation. 

Input:
  value: specifies the total duration for repeating an animation
    string: "5s"
    time.Duration: 5*time.Second = "5s"
    const: KSvgDurIndefinite
    any other type: interface{}

Português:

O atributo repeatDur especifica a duração total para repetir uma animação. 

Entrada:
  value: especifica a duração total para repetir uma animação
    string: "5s"
    time.Duration: 5*time.Second = "5s"
    const: KSvgDurIndefinite
    qualquer outro tipo: interface{}

func (*TagSvgAnimateMotion) Restart 

func (e *TagSvgAnimateMotion) Restart(value interface{}) (ref *TagSvgAnimateMotion)

Restart

English:

The restart attribute specifies whether or not an animation can restart. 

Input:
  value: especifica se uma animação pode ou não reiniciar
    const: KSvgAnimationRestart... (e.g. KSvgAnimationRestartAlways)
    any other type: interface{}

Português:

O atributo restart especifica se uma animação pode ou não reiniciar. 

Entrada:
  value: especifica se uma animação pode ou não reiniciar
    const: KSvgAnimationRestart... (ex. KSvgAnimationRestartAlways)
    qualquer outro tipo: interface{}

func (*TagSvgAnimateMotion) Rotate 

func (e *TagSvgAnimateMotion) Rotate(value interface{}) (ref *TagSvgAnimateMotion)

Rotate

English:

The rotate attribute specifies how the animated element rotates as it travels along a path specified in an <animateMotion> element. 

Input:
  value: specifies how the animated element rotates
    const: KSvgRotate... (e.g. KSvgRotateAutoReverse)
    any other type: interface{}

Português:

O atributo de rotação especifica como o elemento animado gira enquanto percorre um caminho especificado em um elemento <animateMotion>. 

Entrada:
  value: especifica como o elemento animado gira
    const: KSvgRotate... (e.g. KSvgRotateAutoReverse)
    qualquer outro tipo: interface{}

func (*TagSvgAnimateMotion) ShapeRendering 

func (e *TagSvgAnimateMotion) ShapeRendering(value interface{}) (ref *TagSvgAnimateMotion)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgAnimateMotion) StopColor 

func (e *TagSvgAnimateMotion) StopColor(value interface{}) (ref *TagSvgAnimateMotion)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgAnimateMotion) StopOpacity 

func (e *TagSvgAnimateMotion) StopOpacity(value interface{}) (ref *TagSvgAnimateMotion)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgAnimateMotion) Stroke 

func (e *TagSvgAnimateMotion) Stroke(value interface{}) (ref *TagSvgAnimateMotion)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgAnimateMotion) StrokeDasharray 

func (e *TagSvgAnimateMotion) StrokeDasharray(value interface{}) (ref *TagSvgAnimateMotion)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgAnimateMotion) StrokeLineCap 

func (e *TagSvgAnimateMotion) StrokeLineCap(value interface{}) (ref *TagSvgAnimateMotion)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgAnimateMotion) StrokeLineJoin 

func (e *TagSvgAnimateMotion) StrokeLineJoin(value interface{}) (ref *TagSvgAnimateMotion)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgAnimateMotion) StrokeMiterLimit 

func (e *TagSvgAnimateMotion) StrokeMiterLimit(value float64) (ref *TagSvgAnimateMotion)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgAnimateMotion) StrokeOpacity 

func (e *TagSvgAnimateMotion) StrokeOpacity(value interface{}) (ref *TagSvgAnimateMotion)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgAnimateMotion) StrokeWidth 

func (e *TagSvgAnimateMotion) StrokeWidth(value interface{}) (ref *TagSvgAnimateMotion)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgAnimateMotion) Style 

func (e *TagSvgAnimateMotion) Style(value string) (ref *TagSvgAnimateMotion)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgAnimateMotion) Tabindex 

func (e *TagSvgAnimateMotion) Tabindex(value int) (ref *TagSvgAnimateMotion)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgAnimateMotion) Text 

func (e *TagSvgAnimateMotion) Text(value string) (ref *TagSvgAnimateMotion)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgAnimateMotion) TextAnchor 

func (e *TagSvgAnimateMotion) TextAnchor(value interface{}) (ref *TagSvgAnimateMotion)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgAnimateMotion) TextDecoration 

func (e *TagSvgAnimateMotion) TextDecoration(value interface{}) (ref *TagSvgAnimateMotion)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgAnimateMotion) TextRendering 

func (e *TagSvgAnimateMotion) TextRendering(value interface{}) (ref *TagSvgAnimateMotion)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgAnimateMotion) To 

func (e *TagSvgAnimateMotion) To(value interface{}) (ref *TagSvgAnimateMotion)

To

English:

The to attribute indicates the final value of the attribute that will be modified during the animation. 

Input:
  value: final value of the attribute
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1),rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0%, 10%"
    []float64: []float64{0.0, 10.0} = "0, 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s, 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    any other type: interface{}

The value of the attribute will change between the from attribute value and this value.

Português:

O atributo to indica o valor final do atributo que será modificado durante a animação. 

Entrada:
  value: valor final do atributo
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1),rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0%, 10%"
    []float64: []float64{0.0, 10.0} = "0, 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s, 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    qualquer outro tipo: interface{}

O valor do atributo mudará entre o valor do atributo from e este valor.

func (*TagSvgAnimateMotion) Transform 

func (e *TagSvgAnimateMotion) Transform(value interface{}) (ref *TagSvgAnimateMotion)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgAnimateMotion) UnicodeBidi 

func (e *TagSvgAnimateMotion) UnicodeBidi(value interface{}) (ref *TagSvgAnimateMotion)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgAnimateMotion) Values 

func (e *TagSvgAnimateMotion) Values(value interface{}) (ref *TagSvgAnimateMotion)

Values

English:

The values attribute has different meanings, depending upon the context where it's used, either it defines a sequence of values used over the course of an animation, or it's a list of numbers for a color matrix, which is interpreted differently depending on the type of color change to be performed. 

Input:
  value: list of values
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1),rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0%, 10%"
    []float64: []float64{0.0, 10.0} = "0, 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s, 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    any other type: interface{}

Português:

O atributo values tem significados diferentes, dependendo do contexto em que é usado, ou define uma sequência de valores usados ao longo de uma animação, ou é uma lista de números para uma matriz de cores, que é interpretada de forma diferente dependendo do tipo de mudança de cor a ser executada. 

Input:
  value: lista de valores
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1),rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0%, 10%"
    []float64: []float64{0.0, 10.0} = "0, 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s, 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    any other type: interface{}

func (*TagSvgAnimateMotion) VectorEffect 

func (e *TagSvgAnimateMotion) VectorEffect(value interface{}) (ref *TagSvgAnimateMotion)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgAnimateMotion) Visibility 

func (e *TagSvgAnimateMotion) Visibility(value interface{}) (ref *TagSvgAnimateMotion)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgAnimateMotion) WordSpacing 

func (e *TagSvgAnimateMotion) WordSpacing(value interface{}) (ref *TagSvgAnimateMotion)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgAnimateMotion) WritingMode 

func (e *TagSvgAnimateMotion) WritingMode(value interface{}) (ref *TagSvgAnimateMotion)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgAnimateMotion) XLinkHRef deprecated 

func (e *TagSvgAnimateMotion) XLinkHRef(value interface{}) (ref *TagSvgAnimateMotion)

XLinkHRef

English:

Deprecated: use HRef() function

The xlink:href attribute defines a reference to a resource as a reference IRI. The exact meaning of that link depends on the context of each element using it. 

Notes:
  * SVG 2 removed the need for the xlink namespace, so instead of xlink:href you should use href. If you need to
    support earlier browser versions, the deprecated xlink:href attribute can be used as a fallback in addition to
    the href attribute, e.g. <use href="some-id" xlink:href="some-id" x="5" y="5" />.

Português:

Obsoleto: use a função HRef()

O atributo xlink:href define uma referência a um recurso como um IRI de referência. O significado exato desse link depende do contexto de cada elemento que o utiliza. 

Notas:
  * O SVG 2 removeu a necessidade do namespace xlink, então ao invés de xlink:href você deve usar href. Se você
    precisar oferecer suporte a versões anteriores do navegador, o atributo obsoleto xlink:href pode ser usado como
    um substituto além do atributo href, por exemplo, <use href="some-id" xlink:href="some-id" x="5" y="5" >.

func (*TagSvgAnimateMotion) XmlLang 

func (e *TagSvgAnimateMotion) XmlLang(value interface{}) (ref *TagSvgAnimateMotion)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

type TagSvgAnimateTransform 

type TagSvgAnimateTransform struct {
	// contains filtered or unexported fields
}

TagSvgAnimateTransform

English:

The animateTransform element animates a transformation attribute on its target element, thereby allowing animations to control translation, scaling, rotation, and/or skewing.

Português:

O elemento animateTransform anima um atributo de transformação em seu elemento de destino, permitindo assim que as animações controlem a tradução, dimensionamento, rotação e ou inclinação.

func (*TagSvgAnimateTransform) Append 

func (e *TagSvgAnimateTransform) Append(elements ...Compatible) (ref *TagSvgAnimateTransform)

func (*TagSvgAnimateTransform) AppendById 

func (e *TagSvgAnimateTransform) AppendById(appendId string) (ref *TagSvgAnimateTransform)

func (*TagSvgAnimateTransform) AppendToElement 

func (e *TagSvgAnimateTransform) AppendToElement(el js.Value) (ref *TagSvgAnimateTransform)

func (*TagSvgAnimateTransform) AppendToStage 

func (e *TagSvgAnimateTransform) AppendToStage() (ref *TagSvgAnimateTransform)

func (*TagSvgAnimateTransform) AttributeName 

func (e *TagSvgAnimateTransform) AttributeName(attributeName string) (ref *TagSvgAnimateTransform)

AttributeName

English: 

The attributeName attribute indicates the name of the CSS property or attribute of the target element that is going
to be changed during an animation.

Português: 

O atributo attributeName indica o nome da propriedade CSS ou atributo do elemento de destino que será alterado
durante uma animação.

func (*TagSvgAnimateTransform) Begin 

func (e *TagSvgAnimateTransform) Begin(begin interface{}) (ref *TagSvgAnimateTransform)

Begin

English: 

The begin attribute defines when an animation should begin or when an element should be discarded.

 Input:
   begin: defines when an animation should begin or when an element should be discarded.
     offset-value: This value defines a clock-value that represents a point in time relative to the beginning of the
       SVG document (usually the load or DOMContentLoaded event). Negative values are valid.
       (e.g. time.Second*5 or "5s")
     syncbase-value: This value defines a syncbase and an optional offset from that syncbase. The element's
       animation start time is defined relative to the begin or active end of another animation.
       A valid syncbase-value consists of an ID reference to another animation element followed by a dot and either
       begin or end to identify whether to synchronize with the beginning or active end of the referenced animation
       element. An optional offset value as defined in <offset-value> can be appended.
       (e.g. "0s;third.end", "first.end" or "second.end")
     event-value: This value defines an event and an optional offset that determines the time at which the element's
       animation should begin. The animation start time is defined relative to the time that the specified event is
       fired.
       A valid event-value consists of an element ID followed by a dot and one of the supported events for that
       element. All valid events (not necessarily supported by all elements) are defined by the DOM and HTML
       specifications. Those are: 'focus', 'blur', 'focusin', 'focusout', 'activate', 'auxclick', 'click',
       'dblclick', 'mousedown', 'mouseenter', 'mouseleave', 'mousemove', 'mouseout', 'mouseover', 'mouseup',
       'wheel', 'beforeinput', 'input', 'keydown', 'keyup', 'compositionstart', 'compositionupdate',
       'compositionend', 'load', 'unload', 'abort', 'error', 'select', 'resize', 'scroll', 'beginEvent', 'endEvent',
       and 'repeatEvent'. An optional offset value as defined in <offset-value> can be appended.
       (e.g. "startButton.click")
     repeat-value: This value defines a qualified repeat event. The element animation start time is defined relative
       to the time that the repeat event is raised with the specified iteration value.
       A valid repeat value consists of an element ID followed by a dot and the function repeat() with an integer
       value specifying the number of repetitions as parameter. An optional offset value as defined in
       <offset-value> can be appended.
       (e.g. "0s;myLoop.end", "myLoop.begin", "myLoop.repeat(1)" or "myLoop.repeat(2)")
     accessKey-value: This value defines an access key that should trigger the animation. The element animation will
       begin when the user presses the specified key.
       A valid accessKey-value consists of the function accessKey() with the character to be input as parameter. An
       optional offset value as defined in <offset-value> can be appended.
       (e.g. "accessKey(s)")
     wallclock-sync-value: This value defines the animation start time as a real-world clock time.
       A valid wallclock-sync-value consists of the function wallclock() with a time value as parameter. The time
       syntax is based upon the syntax defined in ISO 8601.
       (e.g. time.Now() )
     indefinite: The begin of the animation will be determined by a beginElement() method call or a hyperlink
       targeted to the element.
       (e.g. "infinite")

The attribute value is a semicolon separated list of values. The interpretation of a list of start times is detailed in the SMIL specification in "Evaluation of begin and end time lists". Each individual value can be one of the following: <offset-value>, <syncbase-value>, <event-value>, <repeat-value>, <accessKey-value>, <wallclock-sync-value> or the keyword 'indefinite'.

Português: 

O atributo begin define quando uma animação deve começar ou quando um elemento deve ser descartado.

 Entrada:
   begin: define quando uma animação deve começar ou quando um elemento deve ser descartado.
     offset-value: Esse valor define um valor de relógio que representa um ponto no tempo relativo ao início do
       documento SVG (geralmente o evento load ou DOMContentLoaded). Valores negativos são válidos.
       (e.g. time.Second*5 or "5s")
     syncbase-value: Esse valor define uma base de sincronização e um deslocamento opcional dessa base de
       sincronização. A hora de início da animação do elemento é definida em relação ao início ou fim ativo de outra
       animação.
       Um valor syncbase válido consiste em uma referência de ID para outro elemento de animação seguido por um
       ponto e um início ou fim para identificar se deve ser sincronizado com o início ou o final ativo do elemento
       de animação referenciado. Um valor de deslocamento opcional conforme definido em <offset-value> pode ser
       anexado.
       (e.g. "0s;third.end", "first.end" or "second.end")
     event-value: Esse valor define um evento e um deslocamento opcional que determina a hora em que a animação do
       elemento deve começar. A hora de início da animação é definida em relação à hora em que o evento especificado
       é acionado.
       Um valor de evento válido consiste em um ID de elemento seguido por um ponto e um dos eventos com suporte
       para esse elemento. Todos os eventos válidos (não necessariamente suportados por todos os elementos) são
       definidos pelas especificações DOM e HTML. Esses valores são: 'focus', 'blur', 'focusin', 'focusout',
       'activate', 'auxclick', 'click', 'dblclick', 'mousedown', 'mouseenter', 'mouseleave', 'mousemove',
       'mouseout', 'mouseover', 'mouseup', 'wheel', 'beforeinput', 'input', 'keydown', 'keyup', 'compositionstart',
       'compositionupdate', 'compositionend', 'load', 'unload', 'abort', 'error', 'select', 'resize', 'scroll',
       'beginEvent', 'endEvent', e 'repeatEvent'. Um valor de deslocamento opcional conforme definido em
       <offset-value> pode ser anexado.
       (e.g. "startButton.click")
     repeat-value: Esse valor define um evento de repetição qualificado. A hora de início da animação do elemento é
       definida em relação à hora em que o evento de repetição é gerado com o valor de iteração especificado.
       Um valor de repetição válido consiste em um ID de elemento seguido por um ponto e a função repeat() com um
       valor inteiro especificando o número de repetições como parâmetro. Um valor de deslocamento opcional conforme
       definido em <offset-value> pode ser anexado.
       (e.g. "0s;myLoop.end", "myLoop.begin", "myLoop.repeat(1)" or "myLoop.repeat(2)")
     accessKey-value: Este valor define uma chave de acesso que deve acionar a animação. A animação do elemento
       começará quando o usuário pressionar a tecla especificada.
       Um valor válido de accessKey consiste na função accessKey() com o caractere a ser inserido como parâmetro.
       Um valor de deslocamento opcional conforme definido em <valor de deslocamento> pode ser anexado.
       (e.g. "accessKey(s)")
     wallclock-sync-value: Esse valor define a hora de início da animação como uma hora do relógio do mundo real.
       Um valor wallclock-sync válido consiste na função wallclock() com um valor de tempo como parâmetro. A sintaxe
       de tempo é baseada na sintaxe definida na ISO 8601.
       (e.g. time.Now() )
     indefinite: O início da animação será determinado por uma chamada de método beginElement() ou um hiperlink
       direcionado ao elemento.
       (e.g. "infinite")

O valor do atributo é uma lista de valores separados por ponto e vírgula. A interpretação de uma lista de horários de início é detalhada na especificação SMIL em "Avaliação de listas de horários de início e término". Cada valor individual pode ser um dos seguintes: <offset-value>, <syncbase-value>, <event-value>, <repeat-value>, <accessKey-value>, <wallclock-sync-value> ou a palavra-chave 'indefinite'.

func (*TagSvgAnimateTransform) By 

func (e *TagSvgAnimateTransform) By(by float64) (ref *TagSvgAnimateTransform)

By

English: 

The by attribute specifies a relative offset value for an attribute that will be modified during an animation.

 Input:
   by: specifies a relative offset value for an attribute

The starting value for the attribute is either indicated by specifying it as value for the attribute given in the attributeName or the from attribute.

Português: 

O atributo by especifica um valor de deslocamento relativo para um atributo que será modificado durante uma
animação.

 Entrada:
   by: especifica um valor de deslocamento relativo para um atributo

O valor inicial para o atributo é indicado especificando-o como valor para o atributo fornecido no attributeName ou no atributo from.

func (*TagSvgAnimateTransform) CalcMode 

func (e *TagSvgAnimateTransform) CalcMode(value interface{}) (ref *TagSvgAnimateTransform)

CalcMode

English: 

The calcMode attribute specifies the interpolation mode for the animation.

 Input:
   KSvgCalcModeDiscrete: This specifies that the animation function will jump from one value to the next without
     any interpolation.
   KSvgCalcModeLinear: Simple linear interpolation between values is used to calculate the animation function.
     Except for <animateMotion>, this is the default value.
   KSvgCalcModePaced: Defines interpolation to produce an even pace of change across the animation.
   KSvgCalcModeSpline: Interpolates from one value in the values list to the next according to a time function
     defined by a cubic Bézier spline. The points of the spline are defined in the keyTimes attribute, and the
     control points for each interval are defined in the keySplines attribute.

The default mode is linear, however if the attribute does not support linear interpolation (e.g. for strings), the calcMode attribute is ignored and discrete interpolation is used. 

Notes:
  Default value: KSvgCalcModePaced

Português: 

O atributo calcMode especifica o modo de interpolação para a animação.

 Entrada:
   KSvgCalcModeDiscrete: Isso especifica que a função de animação saltará de um valor para o próximo sem qualquer
     interpolação.
   KSvgCalcModeLinear: A interpolação linear simples entre valores é usada para calcular a função de animação.
     Exceto para <animateMotion>, este é o valor padrão.
   KSvgCalcModePaced: Define a interpolação para produzir um ritmo uniforme de mudança na animação.
   KSvgCalcModeSpline: Interpola de um valor na lista de valores para o próximo de acordo com uma função de tempo
     definida por uma spline de Bézier cúbica. Os pontos do spline são definidos no atributo keyTimes e os pontos
     de controle para cada intervalo são definidos no atributo keySplines.

O modo padrão é linear, no entanto, se o atributo não suportar interpolação linear (por exemplo, para strings), o atributo calcMode será ignorado e a interpolação discreta será usada. 

Notas:
  * Valor padrão: KSvgCalcModePaced

func (*TagSvgAnimateTransform) CreateElement 

func (e *TagSvgAnimateTransform) CreateElement() (ref *TagSvgAnimateTransform)

func (*TagSvgAnimateTransform) Dur 

func (e *TagSvgAnimateTransform) Dur(dur interface{}) (ref *TagSvgAnimateTransform)

Dur

English: 

The dur attribute indicates the simple duration of an animation.

 Input:
   dur: indicates the simple duration of an animation.
     KSvgDur... (e.g. KSvgDurIndefinite)
     time.Duration (e.g. time.Second * 5)

 Notes:
   * The interpolation will not work if the simple duration is indefinite (although this may still be useful for
     <set> elements).

Português: 

O atributo dur indica a duração simples de uma animação.

 Entrada:
   dur: indica a duração simples de uma animação.
     KSvgDur... (ex. KSvgDurIndefinite)
     time.Duration (ex. time.Second * 5)

 Notas:
   * A interpolação não funcionará se a duração simples for indefinida (embora isso ainda possa ser útil para
     elementos <set>).

func (*TagSvgAnimateTransform) End 

func (e *TagSvgAnimateTransform) End(end interface{}) (ref *TagSvgAnimateTransform)

End

English: 

The end attribute defines an end value for the animation that can constrain the active duration.

 Input:
   end: defines an end value for the animation
     offset-value: This value defines a clock-value that represents a point in time relative to the beginning of the
       SVG document (usually the load or DOMContentLoaded event). Negative values are valid.
       (e.g. time.Second*5 or "5s")
     syncbase-value: This value defines a syncbase and an optional offset from that syncbase. The element's
       animation start time is defined relative to the begin or active end of another animation.
       A valid syncbase-value consists of an ID reference to another animation element followed by a dot and either
       begin or end to identify whether to synchronize with the beginning or active end of the referenced animation
       element. An optional offset value as defined in <offset-value> can be appended.
       (e.g. "0s;third.end", "first.end" or "second.end")
     event-value: This value defines an event and an optional offset that determines the time at which the element's
       animation should begin. The animation start time is defined relative to the time that the specified event is
       fired.
       A valid event-value consists of an element ID followed by a dot and one of the supported events for that
       element. All valid events (not necessarily supported by all elements) are defined by the DOM and HTML
       specifications. Those are: 'focus', 'blur', 'focusin', 'focusout', 'activate', 'auxclick', 'click',
       'dblclick', 'mousedown', 'mouseenter', 'mouseleave', 'mousemove', 'mouseout', 'mouseover', 'mouseup',
       'wheel', 'beforeinput', 'input', 'keydown', 'keyup', 'compositionstart', 'compositionupdate',
       'compositionend', 'load', 'unload', 'abort', 'error', 'select', 'resize', 'scroll', 'beginEvent', 'endEvent',
       and 'repeatEvent'. An optional offset value as defined in <offset-value> can be appended.
       (e.g. "startButton.click")
     repeat-value: This value defines a qualified repeat event. The element animation start time is defined relative
       to the time that the repeat event is raised with the specified iteration value.
       A valid repeat value consists of an element ID followed by a dot and the function repeat() with an integer
       value specifying the number of repetitions as parameter. An optional offset value as defined in
       <offset-value> can be appended.
       (e.g. "0s;myLoop.end", "myLoop.begin", "myLoop.repeat(1)" or "myLoop.repeat(2)")
     accessKey-value: This value defines an access key that should trigger the animation. The element animation will
       begin when the user presses the specified key.
       A valid accessKey-value consists of the function accessKey() with the character to be input as parameter. An
       optional offset value as defined in <offset-value> can be appended.
       (e.g. "accessKey(s)")
     wallclock-sync-value: This value defines the animation start time as a real-world clock time.
       A valid wallclock-sync-value consists of the function wallclock() with a time value as parameter. The time
       syntax is based upon the syntax defined in ISO 8601.
       (e.g. time.Now() )
     indefinite: The begin of the animation will be determined by a beginElement() method call or a hyperlink
       targeted to the element.
       (e.g. "infinite")

Portuguese 

O atributo final define um valor final para a animação que pode restringir a duração ativa.

 Entrada:
   end: define um valor final para a animação
     offset-value: Esse valor define um valor de relógio que representa um ponto no tempo relativo ao início do
       documento SVG (geralmente o evento load ou DOMContentLoaded). Valores negativos são válidos.
       (e.g. time.Second*5 or "5s")
     syncbase-value: Esse valor define uma base de sincronização e um deslocamento opcional dessa base de
       sincronização. A hora de início da animação do elemento é definida em relação ao início ou fim ativo de outra
       animação.
       Um valor syncbase válido consiste em uma referência de ID para outro elemento de animação seguido por um
       ponto e um início ou fim para identificar se deve ser sincronizado com o início ou o final ativo do elemento
       de animação referenciado. Um valor de deslocamento opcional conforme definido em <offset-value> pode ser
       anexado.
       (e.g. "0s;third.end", "first.end" or "second.end")
     event-value: Esse valor define um evento e um deslocamento opcional que determina a hora em que a animação do
       elemento deve começar. A hora de início da animação é definida em relação à hora em que o evento especificado
       é acionado.
       Um valor de evento válido consiste em um ID de elemento seguido por um ponto e um dos eventos com suporte
       para esse elemento. Todos os eventos válidos (não necessariamente suportados por todos os elementos) são
       definidos pelas especificações DOM e HTML. Esses valores são: 'focus', 'blur', 'focusin', 'focusout',
       'activate', 'auxclick', 'click', 'dblclick', 'mousedown', 'mouseenter', 'mouseleave', 'mousemove',
       'mouseout', 'mouseover', 'mouseup', 'wheel', 'beforeinput', 'input', 'keydown', 'keyup', 'compositionstart',
       'compositionupdate', 'compositionend', 'load', 'unload', 'abort', 'error', 'select', 'resize', 'scroll',
       'beginEvent', 'endEvent', e 'repeatEvent'. Um valor de deslocamento opcional conforme definido em
       <offset-value> pode ser anexado.
       (e.g. "startButton.click")
     repeat-value: Esse valor define um evento de repetição qualificado. A hora de início da animação do elemento é
       definida em relação à hora em que o evento de repetição é gerado com o valor de iteração especificado.
       Um valor de repetição válido consiste em um ID de elemento seguido por um ponto e a função repeat() com um
       valor inteiro especificando o número de repetições como parâmetro. Um valor de deslocamento opcional conforme
       definido em <offset-value> pode ser anexado.
       (e.g. "0s;myLoop.end", "myLoop.begin", "myLoop.repeat(1)" or "myLoop.repeat(2)")
     accessKey-value: Este valor define uma chave de acesso que deve acionar a animação. A animação do elemento
       começará quando o usuário pressionar a tecla especificada.
       Um valor válido de accessKey consiste na função accessKey() com o caractere a ser inserido como parâmetro.
       Um valor de deslocamento opcional conforme definido em <valor de deslocamento> pode ser anexado.
       (e.g. "accessKey(s)")
     wallclock-sync-value: Esse valor define a hora de início da animação como uma hora do relógio do mundo real.
       Um valor wallclock-sync válido consiste na função wallclock() com um valor de tempo como parâmetro. A sintaxe
       de tempo é baseada na sintaxe definida na ISO 8601.
       (e.g. time.Now() )
     indefinite: O início da animação será determinado por uma chamada de método beginElement() ou um hiperlink
       direcionado ao elemento.
       (e.g. "infinite")

func (*TagSvgAnimateTransform) Fill 

func (e *TagSvgAnimateTransform) Fill(value interface{}) (ref *TagSvgAnimateTransform)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgAnimateTransform) From 

func (e *TagSvgAnimateTransform) From(value interface{}) (ref *TagSvgAnimateTransform)

From

English:

The from attribute indicates the initial value of the attribute that will be modified during the animation. 

Input:
  value: initial value of the attribute
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1),rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0%, 10%"
    []float64: []float64{0.0, 10.0} = "0, 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s, 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    any other type: interface{}

When used with the to attribute, the animation will change the modified attribute from the from value to the to value. When used with the by attribute, the animation will change the attribute relatively from the from value by the value specified in by.

Português:

O atributo from indica o valor inicial do atributo que será modificado durante a animação. 

Entrada:
  value: valor inicial do atributo
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1),rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0%, 10%"
    []float64: []float64{0.0, 10.0} = "0, 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s, 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    qualquer outro tipo: interface{}

Quando usado com o atributo to, a animação mudará o atributo modificado do valor from para o valor to. Quando usado com o atributo by, a animação mudará o atributo relativamente do valor from pelo valor especificado em by.

func (*TagSvgAnimateTransform) Get 

func (e *TagSvgAnimateTransform) Get() (el js.Value)

func (*TagSvgAnimateTransform) HRef 

func (e *TagSvgAnimateTransform) HRef(href string) (ref *TagSvgAnimateTransform)

HRef

English: 

The href attribute defines a link to a resource as a reference URL. The exact meaning of that link depends on the
context of each element using it.

 Notes:
   * Specifications before SVG 2 defined an xlink:href attribute, which is now rendered obsolete by the href
     attribute.
     If you need to support earlier browser versions, the deprecated xlink:href attribute can be used as a fallback
     in addition to the href attribute, e.g. <use href="some-id" xlink:href="some-id x="5" y="5" />.

Português: 

O atributo href define um link para um recurso como um URL de referência. O significado exato desse link depende do
contexto de cada elemento que o utiliza.

 Notas:
   * As especificações anteriores ao SVG 2 definiam um atributo xlink:href, que agora se torna obsoleto pelo
     atributo href.
     Se você precisar oferecer suporte a versões anteriores do navegador, o atributo obsoleto xlink:href pode ser
     usado como um substituto além do atributo href, por exemplo,
     <use href="some-id" xlink:href="some-id x="5" y="5" />.

func (*TagSvgAnimateTransform) Html 

func (e *TagSvgAnimateTransform) Html(value string) (ref *TagSvgAnimateTransform)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgAnimateTransform) Id 

func (e *TagSvgAnimateTransform) Id(id string) (ref *TagSvgAnimateTransform)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgAnimateTransform) Init 

func (e *TagSvgAnimateTransform) Init() (ref *TagSvgAnimateTransform)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgAnimateTransform) KeySplines 

func (e *TagSvgAnimateTransform) KeySplines(value interface{}) (ref *TagSvgAnimateTransform)

KeySplines

English:

The keySplines attribute defines a set of Bézier curve control points associated with the keyTimes list, defining a cubic Bézier function that controls interval pacing.

This attribute is ignored unless the calcMode attribute is set to spline.

If there are any errors in the keySplines specification (bad values, too many or too few values), the animation will not occur.

Português:

O atributo keySplines define um conjunto de pontos de controle da curva Bézier associados à lista keyTimes, definindo uma função Bézier cúbica que controla o ritmo do intervalo.

Esse atributo é ignorado, a menos que o atributo calcMode seja definido como spline.

Se houver algum erro na especificação de keySplines (valores incorretos, muitos ou poucos valores), a animação não ocorrerá.

func (*TagSvgAnimateTransform) KeyTimes 

func (e *TagSvgAnimateTransform) KeyTimes(value interface{}) (ref *TagSvgAnimateTransform)

KeyTimes

English:

The keyTimes attribute represents a list of time values used to control the pacing of the animation. 

Input:
  value: list of time values used to control
    []float64{0.0, 0.5, 1.0}: values="0; 0.5; 1"

Each time in the list corresponds to a value in the values attribute list, and defines when the value is used in the animation.

Each time value in the keyTimes list is specified as a floating point value between 0 and 1 (inclusive), representing a proportional offset into the duration of the animation element.

Português:

O atributo keyTimes representa uma lista de valores de tempo usados para controlar o ritmo da animação. 

Entrada:
  value: lista de valores de tempo usados para controle
    []float64{0.0, 0.5, 1.0}: values="0; 0.5; 1"

Cada vez na lista corresponde a um valor na lista de atributos de valores e define quando o valor é usado na animação.

Cada valor de tempo na lista keyTimes é especificado como um valor de ponto flutuante entre 0 e 1 (inclusive), representando um deslocamento proporcional à duração do elemento de animação.

func (*TagSvgAnimateTransform) Lang 

func (e *TagSvgAnimateTransform) Lang(value interface{}) (ref *TagSvgAnimateTransform)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgAnimateTransform) Max 

func (e *TagSvgAnimateTransform) Max(value interface{}) (ref *TagSvgAnimateTransform)

Max

English:

The max attribute specifies the maximum value of the active animation duration. 

Input:
  value: specifies the maximum value
    float32: 1.0 = "100%"
    time.Duration: 5*time.Second = "5s"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo max especifica o valor máximo da duração da animação ativa. 

Entrada:
  value: especifica o valor máximo
    float32: 1.0 = "100%"
    time.Duration: 5*time.Second = "5s"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgAnimateTransform) Min 

func (e *TagSvgAnimateTransform) Min(value interface{}) (ref *TagSvgAnimateTransform)

Min

English:

The min attribute specifies the minimum value of the active animation duration. 

Input:
  value: specifies the minimum value
    float32: 1.0 = "100%"
    time.Duration: 5*time.Second = "5s"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo min especifica o valor mínimo da duração da animação ativa. 

Input:
  value: especifica o valor mínimo
    float32: 1.0 = "100%"
    time.Duration: 5*time.Second = "5s"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgAnimateTransform) RepeatCount 

func (e *TagSvgAnimateTransform) RepeatCount(value interface{}) (ref *TagSvgAnimateTransform)

RepeatCount

English:

The repeatCount attribute indicates the number of times an animation will take place. 

Input:
  value: indicates the number of times an animation will take place
    int: number of times
    const: KSvgDurIndefinite
    any other type: interface{}

Português:

O atributo repeatCount indica o número de vezes que uma animação ocorrerá. 

Input:
  value: indica o número de vezes que uma animação ocorrerá
    int: número de vezes
    const: KSvgDurIndefinite
    qualquer outro tipo: interface{}

func (*TagSvgAnimateTransform) RepeatDur 

func (e *TagSvgAnimateTransform) RepeatDur(value interface{}) (ref *TagSvgAnimateTransform)

RepeatDur

English:

The repeatDur attribute specifies the total duration for repeating an animation. 

Input:
  value: specifies the total duration for repeating an animation
    string: "5s"
    time.Duration: 5*time.Second = "5s"
    const: KSvgDurIndefinite
    any other type: interface{}

Português:

O atributo repeatDur especifica a duração total para repetir uma animação. 

Entrada:
  value: especifica a duração total para repetir uma animação
    string: "5s"
    time.Duration: 5*time.Second = "5s"
    const: KSvgDurIndefinite
    qualquer outro tipo: interface{}

func (*TagSvgAnimateTransform) Restart 

func (e *TagSvgAnimateTransform) Restart(value interface{}) (ref *TagSvgAnimateTransform)

Restart

English:

The restart attribute specifies whether or not an animation can restart. 

Input:
  value: especifica se uma animação pode ou não reiniciar
    const: KSvgAnimationRestart... (e.g. KSvgAnimationRestartAlways)
    any other type: interface{}

Português:

O atributo restart especifica se uma animação pode ou não reiniciar. 

Entrada:
  value: especifica se uma animação pode ou não reiniciar
    const: KSvgAnimationRestart... (ex. KSvgAnimationRestartAlways)
    qualquer outro tipo: interface{}

func (*TagSvgAnimateTransform) Tabindex 

func (e *TagSvgAnimateTransform) Tabindex(value int) (ref *TagSvgAnimateTransform)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgAnimateTransform) Text 

func (e *TagSvgAnimateTransform) Text(value string) (ref *TagSvgAnimateTransform)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgAnimateTransform) To 

func (e *TagSvgAnimateTransform) To(value interface{}) (ref *TagSvgAnimateTransform)

To

English:

The to attribute indicates the final value of the attribute that will be modified during the animation. 

Input:
  value: final value of the attribute
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1),rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0%, 10%"
    []float64: []float64{0.0, 10.0} = "0, 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s, 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    any other type: interface{}

The value of the attribute will change between the from attribute value and this value.

Português:

O atributo to indica o valor final do atributo que será modificado durante a animação. 

Entrada:
  value: valor final do atributo
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1),rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0%, 10%"
    []float64: []float64{0.0, 10.0} = "0, 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s, 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    qualquer outro tipo: interface{}

O valor do atributo mudará entre o valor do atributo from e este valor.

func (*TagSvgAnimateTransform) Type 

func (e *TagSvgAnimateTransform) Type(value interface{}) (ref *TagSvgAnimateTransform)

Type

English:

Defines the type of transformation, whose values change over time. 

Input:
  value: type of transformation
    const: KSvgTypeTransform... (e.g. KSvgTypeTransformTranslate)
    any other type: interface{}

Português:

Define o tipo de transformação, cujos valores mudam ao longo do tempo. 

Entrada:
  value: tipo de transformação
    const: KSvgTypeTransform... (ex. KSvgTypeTransformTranslate)
    qualquer outro tipo: interface{}

func (*TagSvgAnimateTransform) Values 

func (e *TagSvgAnimateTransform) Values(value interface{}) (ref *TagSvgAnimateTransform)

Values

English:

The values attribute has different meanings, depending upon the context where it's used, either it defines a sequence of values used over the course of an animation, or it's a list of numbers for a color matrix, which is interpreted differently depending on the type of color change to be performed. 

Input:
  value: list of values
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1),rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0%, 10%"
    []float64: []float64{0.0, 10.0} = "0, 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s, 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    any other type: interface{}

Português:

O atributo values tem significados diferentes, dependendo do contexto em que é usado, ou define uma sequência de valores usados ao longo de uma animação, ou é uma lista de números para uma matriz de cores, que é interpretada de forma diferente dependendo do tipo de mudança de cor a ser executada. 

Input:
  value: lista de valores
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1),rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0%, 10%"
    []float64: []float64{0.0, 10.0} = "0, 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s, 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    qualquer outro tipo: interface{}

func (*TagSvgAnimateTransform) XLinkHRef deprecated 

func (e *TagSvgAnimateTransform) XLinkHRef(value interface{}) (ref *TagSvgAnimateTransform)

XLinkHRef

English:

Deprecated: use HRef() function

The xlink:href attribute defines a reference to a resource as a reference IRI. The exact meaning of that link depends on the context of each element using it. 

Notes:
  * SVG 2 removed the need for the xlink namespace, so instead of xlink:href you should use href. If you need to
    support earlier browser versions, the deprecated xlink:href attribute can be used as a fallback in addition to
    the href attribute, e.g. <use href="some-id" xlink:href="some-id" x="5" y="5" />.

Português:

Obsoleto: use a função HRef()

O atributo xlink:href define uma referência a um recurso como um IRI de referência. O significado exato desse link depende do contexto de cada elemento que o utiliza. 

Notas:
  * O SVG 2 removeu a necessidade do namespace xlink, então ao invés de xlink:href você deve usar href. Se você
    precisar oferecer suporte a versões anteriores do navegador, o atributo obsoleto xlink:href pode ser usado como
    um substituto além do atributo href, por exemplo, <use href="some-id" xlink:href="some-id" x="5" y="5" >.

func (*TagSvgAnimateTransform) XmlLang 

func (e *TagSvgAnimateTransform) XmlLang(value interface{}) (ref *TagSvgAnimateTransform)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

type TagSvgCircle 

type TagSvgCircle struct {
	// contains filtered or unexported fields
}

TagSvgCircle

English:

The <circle> SVG element is an SVG basic shape, used to draw circles based on a center point and a radius.

Português:

O elemento SVG <circle> é uma forma básica SVG, usada para desenhar círculos com base em um ponto central e um raio.

func (*TagSvgCircle) AddEventListener 

func (e *TagSvgCircle) AddEventListener(event string, f func(this js.Value, args []js.Value) interface{}) (ref *TagSvgCircle)

func (*TagSvgCircle) Append 

func (e *TagSvgCircle) Append(elements ...Compatible) (ref *TagSvgCircle)

func (*TagSvgCircle) AppendById 

func (e *TagSvgCircle) AppendById(appendId string) (ref *TagSvgCircle)

func (*TagSvgCircle) AppendToElement 

func (e *TagSvgCircle) AppendToElement(el js.Value) (ref *TagSvgCircle)

func (*TagSvgCircle) AppendToStage 

func (e *TagSvgCircle) AppendToStage() (ref *TagSvgCircle)

func (*TagSvgCircle) BaselineShift 

func (e *TagSvgCircle) BaselineShift(baselineShift interface{}) (ref *TagSvgCircle)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgCircle) Class 

func (e *TagSvgCircle) Class(class string) (ref *TagSvgCircle)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgCircle) ClipPath 

func (e *TagSvgCircle) ClipPath(clipPath string) (ref *TagSvgCircle)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgCircle) ClipRule 

func (e *TagSvgCircle) ClipRule(value interface{}) (ref *TagSvgCircle)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgCircle) Color 

func (e *TagSvgCircle) Color(value interface{}) (ref *TagSvgCircle)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgCircle) ColorInterpolation 

func (e *TagSvgCircle) ColorInterpolation(value interface{}) (ref *TagSvgCircle)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgCircle) ColorInterpolationFilters 

func (e *TagSvgCircle) ColorInterpolationFilters(value interface{}) (ref *TagSvgCircle)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgCircle) CreateElement 

func (e *TagSvgCircle) CreateElement() (ref *TagSvgCircle)

func (*TagSvgCircle) Cursor 

func (e *TagSvgCircle) Cursor(cursor SvgCursor) (ref *TagSvgCircle)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgCircle) Cx 

func (e *TagSvgCircle) Cx(value interface{}) (ref *TagSvgCircle)

Cx

English: 

The cx attribute define the x-axis coordinate of a center point.

 Input:
   value: define the x-axis coordinate
     float32: 0.05 = "5%"
     any other type: interface{}

Português: 

O atributo cx define a coordenada do eixo x de um ponto central.

 Entrada:
   value: define a coordenada do eixo x
     float32: 0.05 = "5%"
     qualquer outro tipo: interface{}

func (*TagSvgCircle) Cy 

func (e *TagSvgCircle) Cy(value interface{}) (ref *TagSvgCircle)

Cy

English:

The cy attribute define the y-axis coordinate of a center point. 

Input:
  value: define the y-axis coordinate
    float32: 0.05 = "5%"
    any other type: interface{}

Português: 

O atributo cy define a coordenada do eixo y de um ponto central.

 Entrada:
   value: define a coordenada do eixo y
     float32: 0.05 = "5%"
     qualquer outro tipo: interface{}

func (*TagSvgCircle) Direction 

func (e *TagSvgCircle) Direction(direction SvgDirection) (ref *TagSvgCircle)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgCircle) Display 

func (e *TagSvgCircle) Display(value interface{}) (ref *TagSvgCircle)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgCircle) DominantBaseline 

func (e *TagSvgCircle) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgCircle)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgCircle) Fill 

func (e *TagSvgCircle) Fill(value interface{}) (ref *TagSvgCircle)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgCircle) FillOpacity 

func (e *TagSvgCircle) FillOpacity(value interface{}) (ref *TagSvgCircle)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgCircle) FillRule 

func (e *TagSvgCircle) FillRule(fillRule SvgFillRule) (ref *TagSvgCircle)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgCircle) Filter 

func (e *TagSvgCircle) Filter(filter string) (ref *TagSvgCircle)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgCircle) FloodColor 

func (e *TagSvgCircle) FloodColor(floodColor interface{}) (ref *TagSvgCircle)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgCircle) FloodOpacity 

func (e *TagSvgCircle) FloodOpacity(floodOpacity float64) (ref *TagSvgCircle)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgCircle) FontFamily 

func (e *TagSvgCircle) FontFamily(fontFamily string) (ref *TagSvgCircle)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgCircle) FontSize 

func (e *TagSvgCircle) FontSize(fontSize interface{}) (ref *TagSvgCircle)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgCircle) FontSizeAdjust 

func (e *TagSvgCircle) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgCircle)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgCircle) FontStretch 

func (e *TagSvgCircle) FontStretch(fontStretch interface{}) (ref *TagSvgCircle)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgCircle) FontStyle 

func (e *TagSvgCircle) FontStyle(fontStyle FontStyleRule) (ref *TagSvgCircle)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgCircle) FontVariant 

func (e *TagSvgCircle) FontVariant(value interface{}) (ref *TagSvgCircle)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgCircle) FontWeight 

func (e *TagSvgCircle) FontWeight(value interface{}) (ref *TagSvgCircle)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgCircle) Get 

func (e *TagSvgCircle) Get() (el js.Value)

func (*TagSvgCircle) Html 

func (e *TagSvgCircle) Html(value string) (ref *TagSvgCircle)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgCircle) Id 

func (e *TagSvgCircle) Id(id string) (ref *TagSvgCircle)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgCircle) ImageRendering 

func (e *TagSvgCircle) ImageRendering(imageRendering string) (ref *TagSvgCircle)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgCircle) Init 

func (e *TagSvgCircle) Init() (ref *TagSvgCircle)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgCircle) Lang 

func (e *TagSvgCircle) Lang(value interface{}) (ref *TagSvgCircle)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgCircle) LetterSpacing 

func (e *TagSvgCircle) LetterSpacing(value float64) (ref *TagSvgCircle)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgCircle) LightingColor 

func (e *TagSvgCircle) LightingColor(value interface{}) (ref *TagSvgCircle)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgCircle) MarkerEnd 

func (e *TagSvgCircle) MarkerEnd(value interface{}) (ref *TagSvgCircle)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgCircle) MarkerMid 

func (e *TagSvgCircle) MarkerMid(value interface{}) (ref *TagSvgCircle)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgCircle) MarkerStart 

func (e *TagSvgCircle) MarkerStart(value interface{}) (ref *TagSvgCircle)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgCircle) Mask 

func (e *TagSvgCircle) Mask(value interface{}) (ref *TagSvgCircle)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgCircle) Opacity 

func (e *TagSvgCircle) Opacity(value interface{}) (ref *TagSvgCircle)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgCircle) Overflow 

func (e *TagSvgCircle) Overflow(value interface{}) (ref *TagSvgCircle)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgCircle) PaintOrder 

func (e *TagSvgCircle) PaintOrder(value interface{}) (ref *TagSvgCircle)

PaintOrder

English:

The paint-order attribute specifies the order that the fill, stroke, and markers of a given shape or text element are painted. 

Input:
  value: specifies the order that the fill, stroke, and markers
    const: SvgPaintOrder... (e.g. KSvgPaintOrderStroke)
    any other type: interface{}

Notes:
  * As a presentation attribute, paint-order can be used as a CSS property.

Português:

O atributo paint-order especifica a ordem em que o preenchimento, o traçado e os marcadores de uma determinada forma ou elemento de texto são pintados. 

Entrada:
  value: especifica a ordem em que o preenchimento, o traçado e os marcadores
    const: SvgPaintOrder... (e.g. KSvgPaintOrderStroke)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, paint-order pode ser usado como uma propriedade CSS.

func (*TagSvgCircle) PointerEvents 

func (e *TagSvgCircle) PointerEvents(value interface{}) (ref *TagSvgCircle)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgCircle) R 

func (e *TagSvgCircle) R(value interface{}) (ref *TagSvgCircle)

R

English:

The r attribute defines the radius of a circle. 

Input:
  value: radius of a circle
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo r define o raio de um círculo. 

Input:
  value: raio de um círculo
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgCircle) ShapeRendering 

func (e *TagSvgCircle) ShapeRendering(value interface{}) (ref *TagSvgCircle)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgCircle) StopColor 

func (e *TagSvgCircle) StopColor(value interface{}) (ref *TagSvgCircle)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgCircle) StopOpacity 

func (e *TagSvgCircle) StopOpacity(value interface{}) (ref *TagSvgCircle)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgCircle) Stroke 

func (e *TagSvgCircle) Stroke(value interface{}) (ref *TagSvgCircle)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgCircle) StrokeDashOffset 

func (e *TagSvgCircle) StrokeDashOffset(value interface{}) (ref *TagSvgCircle)

StrokeDashOffset

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    float32: 0.1 = "10%"
    []float32: (e.g. []float32{0.04, 0.01, 0.02}) = "4% 1% 2%"
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    float32: 0.1 = "10%"
    []float32: (e.g. []float32{0.04, 0.01, 0.02}) = "4% 1% 2%"
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgCircle) StrokeDasharray 

func (e *TagSvgCircle) StrokeDasharray(value interface{}) (ref *TagSvgCircle)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgCircle) StrokeLineCap 

func (e *TagSvgCircle) StrokeLineCap(value interface{}) (ref *TagSvgCircle)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgCircle) StrokeLineJoin 

func (e *TagSvgCircle) StrokeLineJoin(value interface{}) (ref *TagSvgCircle)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgCircle) StrokeMiterLimit 

func (e *TagSvgCircle) StrokeMiterLimit(value float64) (ref *TagSvgCircle)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgCircle) StrokeOpacity 

func (e *TagSvgCircle) StrokeOpacity(value interface{}) (ref *TagSvgCircle)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgCircle) StrokeWidth 

func (e *TagSvgCircle) StrokeWidth(value interface{}) (ref *TagSvgCircle)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgCircle) Style 

func (e *TagSvgCircle) Style(value string) (ref *TagSvgCircle)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgCircle) Tabindex 

func (e *TagSvgCircle) Tabindex(value int) (ref *TagSvgCircle)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgCircle) Text 

func (e *TagSvgCircle) Text(value string) (ref *TagSvgCircle)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgCircle) TextAnchor 

func (e *TagSvgCircle) TextAnchor(value interface{}) (ref *TagSvgCircle)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgCircle) TextDecoration 

func (e *TagSvgCircle) TextDecoration(value interface{}) (ref *TagSvgCircle)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgCircle) TextRendering 

func (e *TagSvgCircle) TextRendering(value interface{}) (ref *TagSvgCircle)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgCircle) Transform 

func (e *TagSvgCircle) Transform(value interface{}) (ref *TagSvgCircle)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgCircle) UnicodeBidi 

func (e *TagSvgCircle) UnicodeBidi(value interface{}) (ref *TagSvgCircle)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgCircle) VectorEffect 

func (e *TagSvgCircle) VectorEffect(value interface{}) (ref *TagSvgCircle)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgCircle) Visibility 

func (e *TagSvgCircle) Visibility(value interface{}) (ref *TagSvgCircle)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgCircle) WordSpacing 

func (e *TagSvgCircle) WordSpacing(value interface{}) (ref *TagSvgCircle)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgCircle) WritingMode 

func (e *TagSvgCircle) WritingMode(value interface{}) (ref *TagSvgCircle)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgCircle) XmlLang 

func (e *TagSvgCircle) XmlLang(value interface{}) (ref *TagSvgCircle)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

type TagSvgClipPath 

type TagSvgClipPath struct {
	// contains filtered or unexported fields
}

TagSvgClipPath

English:

The <clipPath> SVG element defines a clipping path, to be used by the clip-path property.

A clipping path restricts the region to which paint can be applied. Conceptually, parts of the drawing that lie outside of the region bounded by the clipping path are not drawn.

Português:

O elemento SVG <clipPath> define um caminho de recorte, a ser usado pela propriedade clip-path.

Um traçado de recorte restringe a região na qual a tinta pode ser aplicada. Conceitualmente, as partes do desenho que estão fora da região delimitada pelo caminho de recorte não são desenhadas.

func (*TagSvgClipPath) Append 

func (e *TagSvgClipPath) Append(elements ...Compatible) (ref *TagSvgClipPath)

func (*TagSvgClipPath) AppendById 

func (e *TagSvgClipPath) AppendById(appendId string) (ref *TagSvgClipPath)

func (*TagSvgClipPath) AppendToElement 

func (e *TagSvgClipPath) AppendToElement(el js.Value) (ref *TagSvgClipPath)

func (*TagSvgClipPath) AppendToStage 

func (e *TagSvgClipPath) AppendToStage() (ref *TagSvgClipPath)

func (*TagSvgClipPath) BaselineShift 

func (e *TagSvgClipPath) BaselineShift(baselineShift interface{}) (ref *TagSvgClipPath)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgClipPath) Class 

func (e *TagSvgClipPath) Class(class string) (ref *TagSvgClipPath)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgClipPath) ClipPath 

func (e *TagSvgClipPath) ClipPath(clipPath string) (ref *TagSvgClipPath)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgClipPath) ClipPathUnits 

func (e *TagSvgClipPath) ClipPathUnits(value interface{}) (ref *TagSvgClipPath)

ClipPathUnits

English: 

The clipPathUnits attribute indicates which coordinate system to use for the contents of the <clipPath> element.

 Input:
   clipPathUnits: indicates which coordinate system to used
     KSvgClipPathUnits... (e.g. KSvgClipPathUnitsUserSpaceOnUse)

Português: 

O atributo clipPathUnits indica qual sistema de coordenadas deve ser usado para o conteúdo do elemento <clipPath>.

 Input:
   clipPathUnits: indica qual sistema de coordenadas deve ser usado
     KSvgClipPathUnits... (ex. KSvgClipPathUnitsUserSpaceOnUse)

func (*TagSvgClipPath) ClipRule 

func (e *TagSvgClipPath) ClipRule(value interface{}) (ref *TagSvgClipPath)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgClipPath) Color 

func (e *TagSvgClipPath) Color(value interface{}) (ref *TagSvgClipPath)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgClipPath) ColorInterpolation 

func (e *TagSvgClipPath) ColorInterpolation(value interface{}) (ref *TagSvgClipPath)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgClipPath) ColorInterpolationFilters 

func (e *TagSvgClipPath) ColorInterpolationFilters(value interface{}) (ref *TagSvgClipPath)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgClipPath) CreateElement 

func (e *TagSvgClipPath) CreateElement() (ref *TagSvgClipPath)

func (*TagSvgClipPath) Cursor 

func (e *TagSvgClipPath) Cursor(cursor SvgCursor) (ref *TagSvgClipPath)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgClipPath) Direction 

func (e *TagSvgClipPath) Direction(direction SvgDirection) (ref *TagSvgClipPath)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgClipPath) Display 

func (e *TagSvgClipPath) Display(value interface{}) (ref *TagSvgClipPath)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgClipPath) DominantBaseline 

func (e *TagSvgClipPath) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgClipPath)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgClipPath) Fill 

func (e *TagSvgClipPath) Fill(value interface{}) (ref *TagSvgClipPath)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgClipPath) FillOpacity 

func (e *TagSvgClipPath) FillOpacity(value interface{}) (ref *TagSvgClipPath)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgClipPath) FillRule 

func (e *TagSvgClipPath) FillRule(fillRule SvgFillRule) (ref *TagSvgClipPath)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgClipPath) Filter 

func (e *TagSvgClipPath) Filter(filter string) (ref *TagSvgClipPath)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgClipPath) FloodColor 

func (e *TagSvgClipPath) FloodColor(floodColor interface{}) (ref *TagSvgClipPath)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgClipPath) FloodOpacity 

func (e *TagSvgClipPath) FloodOpacity(floodOpacity float64) (ref *TagSvgClipPath)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgClipPath) FontFamily 

func (e *TagSvgClipPath) FontFamily(fontFamily string) (ref *TagSvgClipPath)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgClipPath) FontSize 

func (e *TagSvgClipPath) FontSize(fontSize interface{}) (ref *TagSvgClipPath)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgClipPath) FontSizeAdjust 

func (e *TagSvgClipPath) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgClipPath)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgClipPath) FontStretch 

func (e *TagSvgClipPath) FontStretch(fontStretch interface{}) (ref *TagSvgClipPath)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgClipPath) FontStyle 

func (e *TagSvgClipPath) FontStyle(fontStyle FontStyleRule) (ref *TagSvgClipPath)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgClipPath) FontVariant 

func (e *TagSvgClipPath) FontVariant(value interface{}) (ref *TagSvgClipPath)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgClipPath) FontWeight 

func (e *TagSvgClipPath) FontWeight(value interface{}) (ref *TagSvgClipPath)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgClipPath) Get 

func (e *TagSvgClipPath) Get() (el js.Value)

func (*TagSvgClipPath) Html 

func (e *TagSvgClipPath) Html(value string) (ref *TagSvgClipPath)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgClipPath) Id 

func (e *TagSvgClipPath) Id(id string) (ref *TagSvgClipPath)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgClipPath) ImageRendering 

func (e *TagSvgClipPath) ImageRendering(imageRendering string) (ref *TagSvgClipPath)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgClipPath) Init 

func (e *TagSvgClipPath) Init() (ref *TagSvgClipPath)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgClipPath) Lang 

func (e *TagSvgClipPath) Lang(value interface{}) (ref *TagSvgClipPath)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgClipPath) LetterSpacing 

func (e *TagSvgClipPath) LetterSpacing(value float64) (ref *TagSvgClipPath)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgClipPath) LightingColor 

func (e *TagSvgClipPath) LightingColor(value interface{}) (ref *TagSvgClipPath)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgClipPath) MarkerEnd 

func (e *TagSvgClipPath) MarkerEnd(value interface{}) (ref *TagSvgClipPath)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgClipPath) MarkerMid 

func (e *TagSvgClipPath) MarkerMid(value interface{}) (ref *TagSvgClipPath)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgClipPath) MarkerStart 

func (e *TagSvgClipPath) MarkerStart(value interface{}) (ref *TagSvgClipPath)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgClipPath) Mask 

func (e *TagSvgClipPath) Mask(value interface{}) (ref *TagSvgClipPath)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgClipPath) Opacity 

func (e *TagSvgClipPath) Opacity(value interface{}) (ref *TagSvgClipPath)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgClipPath) Overflow 

func (e *TagSvgClipPath) Overflow(value interface{}) (ref *TagSvgClipPath)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgClipPath) PointerEvents 

func (e *TagSvgClipPath) PointerEvents(value interface{}) (ref *TagSvgClipPath)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgClipPath) ShapeRendering 

func (e *TagSvgClipPath) ShapeRendering(value interface{}) (ref *TagSvgClipPath)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgClipPath) StopColor 

func (e *TagSvgClipPath) StopColor(value interface{}) (ref *TagSvgClipPath)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgClipPath) StopOpacity 

func (e *TagSvgClipPath) StopOpacity(value interface{}) (ref *TagSvgClipPath)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgClipPath) Stroke 

func (e *TagSvgClipPath) Stroke(value interface{}) (ref *TagSvgClipPath)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgClipPath) StrokeDasharray 

func (e *TagSvgClipPath) StrokeDasharray(value interface{}) (ref *TagSvgClipPath)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgClipPath) StrokeLineCap 

func (e *TagSvgClipPath) StrokeLineCap(value interface{}) (ref *TagSvgClipPath)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgClipPath) StrokeLineJoin 

func (e *TagSvgClipPath) StrokeLineJoin(value interface{}) (ref *TagSvgClipPath)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgClipPath) StrokeMiterLimit 

func (e *TagSvgClipPath) StrokeMiterLimit(value float64) (ref *TagSvgClipPath)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgClipPath) StrokeOpacity 

func (e *TagSvgClipPath) StrokeOpacity(value interface{}) (ref *TagSvgClipPath)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgClipPath) StrokeWidth 

func (e *TagSvgClipPath) StrokeWidth(value interface{}) (ref *TagSvgClipPath)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgClipPath) Style 

func (e *TagSvgClipPath) Style(value string) (ref *TagSvgClipPath)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgClipPath) Tabindex 

func (e *TagSvgClipPath) Tabindex(value int) (ref *TagSvgClipPath)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgClipPath) Text 

func (e *TagSvgClipPath) Text(value string) (ref *TagSvgClipPath)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgClipPath) TextAnchor 

func (e *TagSvgClipPath) TextAnchor(value interface{}) (ref *TagSvgClipPath)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgClipPath) TextDecoration 

func (e *TagSvgClipPath) TextDecoration(value interface{}) (ref *TagSvgClipPath)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgClipPath) TextRendering 

func (e *TagSvgClipPath) TextRendering(value interface{}) (ref *TagSvgClipPath)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgClipPath) Transform 

func (e *TagSvgClipPath) Transform(value interface{}) (ref *TagSvgClipPath)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgClipPath) UnicodeBidi 

func (e *TagSvgClipPath) UnicodeBidi(value interface{}) (ref *TagSvgClipPath)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgClipPath) VectorEffect 

func (e *TagSvgClipPath) VectorEffect(value interface{}) (ref *TagSvgClipPath)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgClipPath) Visibility 

func (e *TagSvgClipPath) Visibility(value interface{}) (ref *TagSvgClipPath)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgClipPath) WordSpacing 

func (e *TagSvgClipPath) WordSpacing(value interface{}) (ref *TagSvgClipPath)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgClipPath) WritingMode 

func (e *TagSvgClipPath) WritingMode(value interface{}) (ref *TagSvgClipPath)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgClipPath) XmlLang 

func (e *TagSvgClipPath) XmlLang(value interface{}) (ref *TagSvgClipPath)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

type TagSvgDefs 

type TagSvgDefs struct {
	// contains filtered or unexported fields
}

TagSvgDefs

English:

The <defs> element is used to store graphical objects that will be used at a later time.

Objects created inside a <defs> element are not rendered directly. To display them you have to reference them (with a <use> element for example).

Graphical objects can be referenced from anywhere, however, defining these objects inside of a <defs> element promotes understandability of the SVG content and is beneficial to the overall accessibility of the document.

Português:

O elemento <defs> é usado para armazenar objetos gráficos que serão usados posteriormente.

Objetos criados dentro de um elemento <defs> não são renderizados diretamente. Para exibi-los, você deve referenciá-los (com um elemento <use>, por exemplo).

Graphical objects can be referenced from anywhere, however, defining these objects inside of a <defs> element promotes understandability of the SVG content and is beneficial to the overall accessibility of the document.

func (*TagSvgDefs) Append 

func (e *TagSvgDefs) Append(elements ...Compatible) (ref *TagSvgDefs)

func (*TagSvgDefs) AppendById 

func (e *TagSvgDefs) AppendById(appendId string) (ref *TagSvgDefs)

func (*TagSvgDefs) AppendToElement 

func (e *TagSvgDefs) AppendToElement(el js.Value) (ref *TagSvgDefs)

func (*TagSvgDefs) AppendToStage 

func (e *TagSvgDefs) AppendToStage() (ref *TagSvgDefs)

func (*TagSvgDefs) BaselineShift 

func (e *TagSvgDefs) BaselineShift(baselineShift interface{}) (ref *TagSvgDefs)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgDefs) Class 

func (e *TagSvgDefs) Class(class string) (ref *TagSvgDefs)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgDefs) ClipPath 

func (e *TagSvgDefs) ClipPath(clipPath string) (ref *TagSvgDefs)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgDefs) ClipRule 

func (e *TagSvgDefs) ClipRule(value interface{}) (ref *TagSvgDefs)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgDefs) Color 

func (e *TagSvgDefs) Color(value interface{}) (ref *TagSvgDefs)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgDefs) ColorInterpolation 

func (e *TagSvgDefs) ColorInterpolation(value interface{}) (ref *TagSvgDefs)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgDefs) ColorInterpolationFilters 

func (e *TagSvgDefs) ColorInterpolationFilters(value interface{}) (ref *TagSvgDefs)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgDefs) CreateElement 

func (e *TagSvgDefs) CreateElement() (ref *TagSvgDefs)

func (*TagSvgDefs) Cursor 

func (e *TagSvgDefs) Cursor(cursor SvgCursor) (ref *TagSvgDefs)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgDefs) Direction 

func (e *TagSvgDefs) Direction(direction SvgDirection) (ref *TagSvgDefs)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgDefs) Display 

func (e *TagSvgDefs) Display(value interface{}) (ref *TagSvgDefs)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgDefs) DominantBaseline 

func (e *TagSvgDefs) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgDefs)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgDefs) Fill 

func (e *TagSvgDefs) Fill(value interface{}) (ref *TagSvgDefs)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgDefs) FillOpacity 

func (e *TagSvgDefs) FillOpacity(value interface{}) (ref *TagSvgDefs)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgDefs) FillRule 

func (e *TagSvgDefs) FillRule(fillRule SvgFillRule) (ref *TagSvgDefs)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgDefs) Filter 

func (e *TagSvgDefs) Filter(filter string) (ref *TagSvgDefs)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgDefs) FloodColor 

func (e *TagSvgDefs) FloodColor(floodColor interface{}) (ref *TagSvgDefs)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgDefs) FloodOpacity 

func (e *TagSvgDefs) FloodOpacity(floodOpacity float64) (ref *TagSvgDefs)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgDefs) FontFamily 

func (e *TagSvgDefs) FontFamily(fontFamily string) (ref *TagSvgDefs)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgDefs) FontSize 

func (e *TagSvgDefs) FontSize(fontSize interface{}) (ref *TagSvgDefs)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgDefs) FontSizeAdjust 

func (e *TagSvgDefs) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgDefs)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgDefs) FontStretch 

func (e *TagSvgDefs) FontStretch(fontStretch interface{}) (ref *TagSvgDefs)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgDefs) FontStyle 

func (e *TagSvgDefs) FontStyle(fontStyle FontStyleRule) (ref *TagSvgDefs)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgDefs) FontVariant 

func (e *TagSvgDefs) FontVariant(value interface{}) (ref *TagSvgDefs)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgDefs) FontWeight 

func (e *TagSvgDefs) FontWeight(value interface{}) (ref *TagSvgDefs)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgDefs) Get 

func (e *TagSvgDefs) Get() (el js.Value)

func (*TagSvgDefs) Html 

func (e *TagSvgDefs) Html(value string) (ref *TagSvgDefs)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgDefs) Id 

func (e *TagSvgDefs) Id(id string) (ref *TagSvgDefs)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgDefs) ImageRendering 

func (e *TagSvgDefs) ImageRendering(imageRendering string) (ref *TagSvgDefs)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgDefs) Init 

func (e *TagSvgDefs) Init() (ref *TagSvgDefs)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgDefs) Lang 

func (e *TagSvgDefs) Lang(value interface{}) (ref *TagSvgDefs)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgDefs) LetterSpacing 

func (e *TagSvgDefs) LetterSpacing(value float64) (ref *TagSvgDefs)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgDefs) LightingColor 

func (e *TagSvgDefs) LightingColor(value interface{}) (ref *TagSvgDefs)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgDefs) MarkerEnd 

func (e *TagSvgDefs) MarkerEnd(value interface{}) (ref *TagSvgDefs)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgDefs) MarkerMid 

func (e *TagSvgDefs) MarkerMid(value interface{}) (ref *TagSvgDefs)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgDefs) MarkerStart 

func (e *TagSvgDefs) MarkerStart(value interface{}) (ref *TagSvgDefs)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgDefs) Mask 

func (e *TagSvgDefs) Mask(value interface{}) (ref *TagSvgDefs)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgDefs) Opacity 

func (e *TagSvgDefs) Opacity(value interface{}) (ref *TagSvgDefs)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgDefs) Overflow 

func (e *TagSvgDefs) Overflow(value interface{}) (ref *TagSvgDefs)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgDefs) PointerEvents 

func (e *TagSvgDefs) PointerEvents(value interface{}) (ref *TagSvgDefs)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgDefs) ShapeRendering 

func (e *TagSvgDefs) ShapeRendering(value interface{}) (ref *TagSvgDefs)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgDefs) StopColor 

func (e *TagSvgDefs) StopColor(value interface{}) (ref *TagSvgDefs)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgDefs) StopOpacity 

func (e *TagSvgDefs) StopOpacity(value interface{}) (ref *TagSvgDefs)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgDefs) Stroke 

func (e *TagSvgDefs) Stroke(value interface{}) (ref *TagSvgDefs)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgDefs) StrokeDasharray 

func (e *TagSvgDefs) StrokeDasharray(value interface{}) (ref *TagSvgDefs)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgDefs) StrokeLineCap 

func (e *TagSvgDefs) StrokeLineCap(value interface{}) (ref *TagSvgDefs)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgDefs) StrokeLineJoin 

func (e *TagSvgDefs) StrokeLineJoin(value interface{}) (ref *TagSvgDefs)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgDefs) StrokeMiterLimit 

func (e *TagSvgDefs) StrokeMiterLimit(value float64) (ref *TagSvgDefs)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgDefs) StrokeOpacity 

func (e *TagSvgDefs) StrokeOpacity(value interface{}) (ref *TagSvgDefs)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgDefs) StrokeWidth 

func (e *TagSvgDefs) StrokeWidth(value interface{}) (ref *TagSvgDefs)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgDefs) Style 

func (e *TagSvgDefs) Style(value string) (ref *TagSvgDefs)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgDefs) Tabindex 

func (e *TagSvgDefs) Tabindex(value int) (ref *TagSvgDefs)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgDefs) Text 

func (e *TagSvgDefs) Text(value string) (ref *TagSvgDefs)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgDefs) TextAnchor 

func (e *TagSvgDefs) TextAnchor(value interface{}) (ref *TagSvgDefs)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgDefs) TextDecoration 

func (e *TagSvgDefs) TextDecoration(value interface{}) (ref *TagSvgDefs)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgDefs) TextRendering 

func (e *TagSvgDefs) TextRendering(value interface{}) (ref *TagSvgDefs)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgDefs) Transform 

func (e *TagSvgDefs) Transform(value interface{}) (ref *TagSvgDefs)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgDefs) UnicodeBidi 

func (e *TagSvgDefs) UnicodeBidi(value interface{}) (ref *TagSvgDefs)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgDefs) VectorEffect 

func (e *TagSvgDefs) VectorEffect(value interface{}) (ref *TagSvgDefs)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgDefs) Visibility 

func (e *TagSvgDefs) Visibility(value interface{}) (ref *TagSvgDefs)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgDefs) WordSpacing 

func (e *TagSvgDefs) WordSpacing(value interface{}) (ref *TagSvgDefs)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgDefs) WritingMode 

func (e *TagSvgDefs) WritingMode(value interface{}) (ref *TagSvgDefs)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgDefs) XmlLang 

func (e *TagSvgDefs) XmlLang(value interface{}) (ref *TagSvgDefs)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

type TagSvgDesc 

type TagSvgDesc struct {
	// contains filtered or unexported fields
}

TagSvgDesc

English:

The <desc> element provides an accessible, long-text description of any SVG container element or graphics element.

Text in a <desc> element is not rendered as part of the graphic. If the element can be described by visible text, it is possible to reference that text with the aria-describedby attribute. If aria-describedby is used, it will take precedence over <desc>.

The hidden text of a <desc> element can also be concatenated with the visible text of other elements using multiple IDs in an aria-describedby value. In that case, the <desc> element must provide an ID for reference.

Português:

O elemento <desc> fornece uma descrição de texto longo e acessível de qualquer elemento de contêiner SVG ou elemento gráfico.

O texto em um elemento <desc> não é renderizado como parte do gráfico. Se o elemento puder ser descrito por texto visível, é possível fazer referência a esse texto com o atributo aria-describedby. Se aria-describedby for usado, terá precedência sobre <desc>.

O texto oculto de um elemento <desc> também pode ser concatenado com o texto visível de outros elementos usando vários IDs em um valor descrito por aria. Nesse caso, o elemento <desc> deve fornecer um ID para referência.

func (*TagSvgDesc) Append 

func (e *TagSvgDesc) Append(elements ...Compatible) (ref *TagSvgDesc)

func (*TagSvgDesc) AppendById 

func (e *TagSvgDesc) AppendById(appendId string) (ref *TagSvgDesc)

func (*TagSvgDesc) AppendToElement 

func (e *TagSvgDesc) AppendToElement(el js.Value) (ref *TagSvgDesc)

func (*TagSvgDesc) AppendToStage 

func (e *TagSvgDesc) AppendToStage() (ref *TagSvgDesc)

func (*TagSvgDesc) BaselineShift 

func (e *TagSvgDesc) BaselineShift(baselineShift interface{}) (ref *TagSvgDesc)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgDesc) Class 

func (e *TagSvgDesc) Class(class string) (ref *TagSvgDesc)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgDesc) ClipPath 

func (e *TagSvgDesc) ClipPath(clipPath string) (ref *TagSvgDesc)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgDesc) ClipRule 

func (e *TagSvgDesc) ClipRule(value interface{}) (ref *TagSvgDesc)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgDesc) Color 

func (e *TagSvgDesc) Color(value interface{}) (ref *TagSvgDesc)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgDesc) ColorInterpolation 

func (e *TagSvgDesc) ColorInterpolation(value interface{}) (ref *TagSvgDesc)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgDesc) ColorInterpolationFilters 

func (e *TagSvgDesc) ColorInterpolationFilters(value interface{}) (ref *TagSvgDesc)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgDesc) CreateElement 

func (e *TagSvgDesc) CreateElement() (ref *TagSvgDesc)

func (*TagSvgDesc) Cursor 

func (e *TagSvgDesc) Cursor(cursor SvgCursor) (ref *TagSvgDesc)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgDesc) Description 

func (e *TagSvgDesc) Description(value string) (ref *TagSvgDesc)

Description

English:

Add a description

Português:

Adiciona uma descrição

func (*TagSvgDesc) Direction 

func (e *TagSvgDesc) Direction(direction SvgDirection) (ref *TagSvgDesc)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgDesc) Display 

func (e *TagSvgDesc) Display(value interface{}) (ref *TagSvgDesc)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgDesc) DominantBaseline 

func (e *TagSvgDesc) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgDesc)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgDesc) Fill 

func (e *TagSvgDesc) Fill(value interface{}) (ref *TagSvgDesc)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgDesc) FillOpacity 

func (e *TagSvgDesc) FillOpacity(value interface{}) (ref *TagSvgDesc)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgDesc) FillRule 

func (e *TagSvgDesc) FillRule(fillRule SvgFillRule) (ref *TagSvgDesc)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgDesc) Filter 

func (e *TagSvgDesc) Filter(filter string) (ref *TagSvgDesc)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgDesc) FloodColor 

func (e *TagSvgDesc) FloodColor(floodColor interface{}) (ref *TagSvgDesc)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgDesc) FloodOpacity 

func (e *TagSvgDesc) FloodOpacity(floodOpacity float64) (ref *TagSvgDesc)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgDesc) FontFamily 

func (e *TagSvgDesc) FontFamily(fontFamily string) (ref *TagSvgDesc)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgDesc) FontSize 

func (e *TagSvgDesc) FontSize(fontSize interface{}) (ref *TagSvgDesc)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgDesc) FontSizeAdjust 

func (e *TagSvgDesc) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgDesc)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgDesc) FontStretch 

func (e *TagSvgDesc) FontStretch(fontStretch interface{}) (ref *TagSvgDesc)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgDesc) FontStyle 

func (e *TagSvgDesc) FontStyle(fontStyle FontStyleRule) (ref *TagSvgDesc)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgDesc) FontVariant 

func (e *TagSvgDesc) FontVariant(value interface{}) (ref *TagSvgDesc)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgDesc) FontWeight 

func (e *TagSvgDesc) FontWeight(value interface{}) (ref *TagSvgDesc)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgDesc) Get 

func (e *TagSvgDesc) Get() (el js.Value)

func (*TagSvgDesc) Html 

func (e *TagSvgDesc) Html(value string) (ref *TagSvgDesc)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgDesc) Id 

func (e *TagSvgDesc) Id(id string) (ref *TagSvgDesc)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgDesc) ImageRendering 

func (e *TagSvgDesc) ImageRendering(imageRendering string) (ref *TagSvgDesc)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgDesc) Init 

func (e *TagSvgDesc) Init() (ref *TagSvgDesc)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgDesc) Lang 

func (e *TagSvgDesc) Lang(value interface{}) (ref *TagSvgDesc)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgDesc) LetterSpacing 

func (e *TagSvgDesc) LetterSpacing(value float64) (ref *TagSvgDesc)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgDesc) LightingColor 

func (e *TagSvgDesc) LightingColor(value interface{}) (ref *TagSvgDesc)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgDesc) MarkerEnd 

func (e *TagSvgDesc) MarkerEnd(value interface{}) (ref *TagSvgDesc)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgDesc) MarkerMid 

func (e *TagSvgDesc) MarkerMid(value interface{}) (ref *TagSvgDesc)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgDesc) MarkerStart 

func (e *TagSvgDesc) MarkerStart(value interface{}) (ref *TagSvgDesc)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgDesc) Mask 

func (e *TagSvgDesc) Mask(value interface{}) (ref *TagSvgDesc)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgDesc) Opacity 

func (e *TagSvgDesc) Opacity(value interface{}) (ref *TagSvgDesc)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgDesc) Overflow 

func (e *TagSvgDesc) Overflow(value interface{}) (ref *TagSvgDesc)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgDesc) PointerEvents 

func (e *TagSvgDesc) PointerEvents(value interface{}) (ref *TagSvgDesc)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgDesc) ShapeRendering 

func (e *TagSvgDesc) ShapeRendering(value interface{}) (ref *TagSvgDesc)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgDesc) StopColor 

func (e *TagSvgDesc) StopColor(value interface{}) (ref *TagSvgDesc)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgDesc) StopOpacity 

func (e *TagSvgDesc) StopOpacity(value interface{}) (ref *TagSvgDesc)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgDesc) Stroke 

func (e *TagSvgDesc) Stroke(value interface{}) (ref *TagSvgDesc)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgDesc) StrokeDasharray 

func (e *TagSvgDesc) StrokeDasharray(value interface{}) (ref *TagSvgDesc)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgDesc) StrokeLineCap 

func (e *TagSvgDesc) StrokeLineCap(value interface{}) (ref *TagSvgDesc)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgDesc) StrokeLineJoin 

func (e *TagSvgDesc) StrokeLineJoin(value interface{}) (ref *TagSvgDesc)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgDesc) StrokeMiterLimit 

func (e *TagSvgDesc) StrokeMiterLimit(value float64) (ref *TagSvgDesc)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgDesc) StrokeOpacity 

func (e *TagSvgDesc) StrokeOpacity(value interface{}) (ref *TagSvgDesc)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgDesc) StrokeWidth 

func (e *TagSvgDesc) StrokeWidth(value interface{}) (ref *TagSvgDesc)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgDesc) Style 

func (e *TagSvgDesc) Style(value string) (ref *TagSvgDesc)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgDesc) Tabindex 

func (e *TagSvgDesc) Tabindex(value int) (ref *TagSvgDesc)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgDesc) Text 

func (e *TagSvgDesc) Text(value string) (ref *TagSvgDesc)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgDesc) TextAnchor 

func (e *TagSvgDesc) TextAnchor(value interface{}) (ref *TagSvgDesc)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgDesc) TextDecoration 

func (e *TagSvgDesc) TextDecoration(value interface{}) (ref *TagSvgDesc)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgDesc) TextRendering 

func (e *TagSvgDesc) TextRendering(value interface{}) (ref *TagSvgDesc)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgDesc) Transform 

func (e *TagSvgDesc) Transform(value interface{}) (ref *TagSvgDesc)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgDesc) UnicodeBidi 

func (e *TagSvgDesc) UnicodeBidi(value interface{}) (ref *TagSvgDesc)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgDesc) VectorEffect 

func (e *TagSvgDesc) VectorEffect(value interface{}) (ref *TagSvgDesc)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgDesc) Visibility 

func (e *TagSvgDesc) Visibility(value interface{}) (ref *TagSvgDesc)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgDesc) WordSpacing 

func (e *TagSvgDesc) WordSpacing(value interface{}) (ref *TagSvgDesc)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgDesc) WritingMode 

func (e *TagSvgDesc) WritingMode(value interface{}) (ref *TagSvgDesc)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgDesc) XmlLang 

func (e *TagSvgDesc) XmlLang(value interface{}) (ref *TagSvgDesc)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

type TagSvgDiscard 

type TagSvgDiscard struct {
	// contains filtered or unexported fields
}

TagSvgDiscard

English:

The <discard> SVG element allows authors to specify the time at which particular elements are to be discarded, thereby reducing the resources required by an SVG user agent. This is particularly useful to help SVG viewers conserve memory while displaying long-running documents.

The <discard> element may occur wherever the <animate> element may.

Português:

The <discard> SVG element allows authors to specify the time at which particular elements are to be discarded, thereby reducing the resources required by an SVG user agent. This is particularly useful to help SVG viewers conserve memory while displaying long-running documents.

The <discard> element may occur wherever the <animate> element may.

func (*TagSvgDiscard) Append 

func (e *TagSvgDiscard) Append(elements ...Compatible) (ref *TagSvgDiscard)

func (*TagSvgDiscard) AppendById 

func (e *TagSvgDiscard) AppendById(appendId string) (ref *TagSvgDiscard)

func (*TagSvgDiscard) AppendToElement 

func (e *TagSvgDiscard) AppendToElement(el js.Value) (ref *TagSvgDiscard)

func (*TagSvgDiscard) AppendToStage 

func (e *TagSvgDiscard) AppendToStage() (ref *TagSvgDiscard)

func (*TagSvgDiscard) BaselineShift 

func (e *TagSvgDiscard) BaselineShift(baselineShift interface{}) (ref *TagSvgDiscard)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgDiscard) Class 

func (e *TagSvgDiscard) Class(class string) (ref *TagSvgDiscard)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgDiscard) ClipPath 

func (e *TagSvgDiscard) ClipPath(clipPath string) (ref *TagSvgDiscard)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgDiscard) ClipRule 

func (e *TagSvgDiscard) ClipRule(value interface{}) (ref *TagSvgDiscard)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgDiscard) Color 

func (e *TagSvgDiscard) Color(value interface{}) (ref *TagSvgDiscard)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgDiscard) ColorInterpolation 

func (e *TagSvgDiscard) ColorInterpolation(value interface{}) (ref *TagSvgDiscard)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgDiscard) ColorInterpolationFilters 

func (e *TagSvgDiscard) ColorInterpolationFilters(value interface{}) (ref *TagSvgDiscard)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgDiscard) CreateElement 

func (e *TagSvgDiscard) CreateElement() (ref *TagSvgDiscard)

func (*TagSvgDiscard) Cursor 

func (e *TagSvgDiscard) Cursor(cursor SvgCursor) (ref *TagSvgDiscard)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgDiscard) Direction 

func (e *TagSvgDiscard) Direction(direction SvgDirection) (ref *TagSvgDiscard)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgDiscard) Display 

func (e *TagSvgDiscard) Display(value interface{}) (ref *TagSvgDiscard)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgDiscard) DominantBaseline 

func (e *TagSvgDiscard) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgDiscard)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgDiscard) Fill 

func (e *TagSvgDiscard) Fill(value interface{}) (ref *TagSvgDiscard)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgDiscard) FillOpacity 

func (e *TagSvgDiscard) FillOpacity(value interface{}) (ref *TagSvgDiscard)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgDiscard) FillRule 

func (e *TagSvgDiscard) FillRule(fillRule SvgFillRule) (ref *TagSvgDiscard)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgDiscard) Filter 

func (e *TagSvgDiscard) Filter(filter string) (ref *TagSvgDiscard)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgDiscard) FloodColor 

func (e *TagSvgDiscard) FloodColor(floodColor interface{}) (ref *TagSvgDiscard)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgDiscard) FloodOpacity 

func (e *TagSvgDiscard) FloodOpacity(floodOpacity float64) (ref *TagSvgDiscard)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgDiscard) FontFamily 

func (e *TagSvgDiscard) FontFamily(fontFamily string) (ref *TagSvgDiscard)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgDiscard) FontSize 

func (e *TagSvgDiscard) FontSize(fontSize interface{}) (ref *TagSvgDiscard)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgDiscard) FontSizeAdjust 

func (e *TagSvgDiscard) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgDiscard)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgDiscard) FontStretch 

func (e *TagSvgDiscard) FontStretch(fontStretch interface{}) (ref *TagSvgDiscard)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgDiscard) FontStyle 

func (e *TagSvgDiscard) FontStyle(fontStyle FontStyleRule) (ref *TagSvgDiscard)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgDiscard) FontVariant 

func (e *TagSvgDiscard) FontVariant(value interface{}) (ref *TagSvgDiscard)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgDiscard) FontWeight 

func (e *TagSvgDiscard) FontWeight(value interface{}) (ref *TagSvgDiscard)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgDiscard) Get 

func (e *TagSvgDiscard) Get() (el js.Value)

func (*TagSvgDiscard) Html 

func (e *TagSvgDiscard) Html(value string) (ref *TagSvgDiscard)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgDiscard) Id 

func (e *TagSvgDiscard) Id(id string) (ref *TagSvgDiscard)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgDiscard) ImageRendering 

func (e *TagSvgDiscard) ImageRendering(imageRendering string) (ref *TagSvgDiscard)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgDiscard) Init 

func (e *TagSvgDiscard) Init() (ref *TagSvgDiscard)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgDiscard) Lang 

func (e *TagSvgDiscard) Lang(value interface{}) (ref *TagSvgDiscard)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgDiscard) LetterSpacing 

func (e *TagSvgDiscard) LetterSpacing(value float64) (ref *TagSvgDiscard)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgDiscard) LightingColor 

func (e *TagSvgDiscard) LightingColor(value interface{}) (ref *TagSvgDiscard)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgDiscard) MarkerEnd 

func (e *TagSvgDiscard) MarkerEnd(value interface{}) (ref *TagSvgDiscard)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgDiscard) MarkerMid 

func (e *TagSvgDiscard) MarkerMid(value interface{}) (ref *TagSvgDiscard)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgDiscard) MarkerStart 

func (e *TagSvgDiscard) MarkerStart(value interface{}) (ref *TagSvgDiscard)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgDiscard) Mask 

func (e *TagSvgDiscard) Mask(value interface{}) (ref *TagSvgDiscard)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgDiscard) Opacity 

func (e *TagSvgDiscard) Opacity(value interface{}) (ref *TagSvgDiscard)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgDiscard) Overflow 

func (e *TagSvgDiscard) Overflow(value interface{}) (ref *TagSvgDiscard)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgDiscard) PointerEvents 

func (e *TagSvgDiscard) PointerEvents(value interface{}) (ref *TagSvgDiscard)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgDiscard) Script 

func (e *TagSvgDiscard) Script(value string) (ref *TagSvgDiscard)

Script

English:

Adds a javascript script to run when the element is discarded.

Português:

Adiciona um script javascript para ser executado quando o elemento é descartado.

fixme: append(tag script) https://developer.mozilla.org/en-US/docs/Web/SVG/Element/script

func (*TagSvgDiscard) ShapeRendering 

func (e *TagSvgDiscard) ShapeRendering(value interface{}) (ref *TagSvgDiscard)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgDiscard) StopColor 

func (e *TagSvgDiscard) StopColor(value interface{}) (ref *TagSvgDiscard)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgDiscard) StopOpacity 

func (e *TagSvgDiscard) StopOpacity(value interface{}) (ref *TagSvgDiscard)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgDiscard) Stroke 

func (e *TagSvgDiscard) Stroke(value interface{}) (ref *TagSvgDiscard)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgDiscard) StrokeDasharray 

func (e *TagSvgDiscard) StrokeDasharray(value interface{}) (ref *TagSvgDiscard)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgDiscard) StrokeLineCap 

func (e *TagSvgDiscard) StrokeLineCap(value interface{}) (ref *TagSvgDiscard)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgDiscard) StrokeLineJoin 

func (e *TagSvgDiscard) StrokeLineJoin(value interface{}) (ref *TagSvgDiscard)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgDiscard) StrokeMiterLimit 

func (e *TagSvgDiscard) StrokeMiterLimit(value float64) (ref *TagSvgDiscard)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgDiscard) StrokeOpacity 

func (e *TagSvgDiscard) StrokeOpacity(value interface{}) (ref *TagSvgDiscard)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgDiscard) StrokeWidth 

func (e *TagSvgDiscard) StrokeWidth(value interface{}) (ref *TagSvgDiscard)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgDiscard) Style 

func (e *TagSvgDiscard) Style(value string) (ref *TagSvgDiscard)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgDiscard) Tabindex 

func (e *TagSvgDiscard) Tabindex(value int) (ref *TagSvgDiscard)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgDiscard) Text 

func (e *TagSvgDiscard) Text(value string) (ref *TagSvgDiscard)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgDiscard) TextAnchor 

func (e *TagSvgDiscard) TextAnchor(value interface{}) (ref *TagSvgDiscard)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgDiscard) TextDecoration 

func (e *TagSvgDiscard) TextDecoration(value interface{}) (ref *TagSvgDiscard)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgDiscard) TextRendering 

func (e *TagSvgDiscard) TextRendering(value interface{}) (ref *TagSvgDiscard)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgDiscard) Transform 

func (e *TagSvgDiscard) Transform(value interface{}) (ref *TagSvgDiscard)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgDiscard) UnicodeBidi 

func (e *TagSvgDiscard) UnicodeBidi(value interface{}) (ref *TagSvgDiscard)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgDiscard) VectorEffect 

func (e *TagSvgDiscard) VectorEffect(value interface{}) (ref *TagSvgDiscard)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgDiscard) Visibility 

func (e *TagSvgDiscard) Visibility(value interface{}) (ref *TagSvgDiscard)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgDiscard) WordSpacing 

func (e *TagSvgDiscard) WordSpacing(value interface{}) (ref *TagSvgDiscard)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgDiscard) WritingMode 

func (e *TagSvgDiscard) WritingMode(value interface{}) (ref *TagSvgDiscard)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgDiscard) XmlLang 

func (e *TagSvgDiscard) XmlLang(value interface{}) (ref *TagSvgDiscard)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

type TagSvgEllipse 

type TagSvgEllipse struct {
	// contains filtered or unexported fields
}

TagSvgEllipse

English:

The <ellipse> element is an SVG basic shape, used to create ellipses based on a center coordinate, and both their x and y radius. 

Notes:
  * Ellipses are unable to specify the exact orientation of the ellipse (if, for example, you wanted to draw an
    ellipse tilted at a 45 degree angle), but it can be rotated by using the transform attribute.

Português:

O elemento <ellipse> é uma forma básica SVG, usada para criar elipses com base em uma coordenada central e em seus raios x e y. 

Note:
  * As elipses não podem especificar a orientação exata da elipse (se, por exemplo, você quiser desenhar uma
    elipse inclinada em um ângulo de 45 graus), mas ela pode ser girada usando o atributo transform.

func (*TagSvgEllipse) Append 

func (e *TagSvgEllipse) Append(elements ...Compatible) (ref *TagSvgEllipse)

func (*TagSvgEllipse) AppendById 

func (e *TagSvgEllipse) AppendById(appendId string) (ref *TagSvgEllipse)

func (*TagSvgEllipse) AppendToElement 

func (e *TagSvgEllipse) AppendToElement(el js.Value) (ref *TagSvgEllipse)

func (*TagSvgEllipse) AppendToStage 

func (e *TagSvgEllipse) AppendToStage() (ref *TagSvgEllipse)

func (*TagSvgEllipse) BaselineShift 

func (e *TagSvgEllipse) BaselineShift(baselineShift interface{}) (ref *TagSvgEllipse)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgEllipse) Class 

func (e *TagSvgEllipse) Class(class string) (ref *TagSvgEllipse)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgEllipse) ClipPath 

func (e *TagSvgEllipse) ClipPath(clipPath string) (ref *TagSvgEllipse)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgEllipse) ClipRule 

func (e *TagSvgEllipse) ClipRule(value interface{}) (ref *TagSvgEllipse)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgEllipse) Color 

func (e *TagSvgEllipse) Color(value interface{}) (ref *TagSvgEllipse)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgEllipse) ColorInterpolation 

func (e *TagSvgEllipse) ColorInterpolation(value interface{}) (ref *TagSvgEllipse)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgEllipse) ColorInterpolationFilters 

func (e *TagSvgEllipse) ColorInterpolationFilters(value interface{}) (ref *TagSvgEllipse)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgEllipse) CreateElement 

func (e *TagSvgEllipse) CreateElement() (ref *TagSvgEllipse)

func (*TagSvgEllipse) Cursor 

func (e *TagSvgEllipse) Cursor(cursor SvgCursor) (ref *TagSvgEllipse)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgEllipse) Cx 

func (e *TagSvgEllipse) Cx(value interface{}) (ref *TagSvgEllipse)

Cx

English: 

The cx attribute define the x-axis coordinate of a center point.

 Input:
   value: define the x-axis coordinate
     float32: 0.05 = "5%"
     any other type: interface{}

Português: 

O atributo cx define a coordenada do eixo x de um ponto central.

 Entrada:
   value: define a coordenada do eixo x
     float32: 0.05 = "5%"
     qualquer outro tipo: interface{}

func (*TagSvgEllipse) Cy 

func (e *TagSvgEllipse) Cy(value interface{}) (ref *TagSvgEllipse)

Cy

English:

The cy attribute define the y-axis coordinate of a center point. 

Input:
  value: define the y-axis coordinate
    float32: 0.05 = "5%"
    any other type: interface{}

Português: 

O atributo cy define a coordenada do eixo y de um ponto central.

 Entrada:
   value: define a coordenada do eixo y
     float32: 0.05 = "5%"
     qualquer outro tipo: interface{}

func (*TagSvgEllipse) Direction 

func (e *TagSvgEllipse) Direction(direction SvgDirection) (ref *TagSvgEllipse)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgEllipse) Display 

func (e *TagSvgEllipse) Display(value interface{}) (ref *TagSvgEllipse)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgEllipse) DominantBaseline 

func (e *TagSvgEllipse) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgEllipse)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgEllipse) Fill 

func (e *TagSvgEllipse) Fill(value interface{}) (ref *TagSvgEllipse)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgEllipse) FillOpacity 

func (e *TagSvgEllipse) FillOpacity(value interface{}) (ref *TagSvgEllipse)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgEllipse) FillRule 

func (e *TagSvgEllipse) FillRule(fillRule SvgFillRule) (ref *TagSvgEllipse)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgEllipse) Filter 

func (e *TagSvgEllipse) Filter(filter string) (ref *TagSvgEllipse)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgEllipse) FloodColor 

func (e *TagSvgEllipse) FloodColor(floodColor interface{}) (ref *TagSvgEllipse)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgEllipse) FloodOpacity 

func (e *TagSvgEllipse) FloodOpacity(floodOpacity float64) (ref *TagSvgEllipse)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgEllipse) FontFamily 

func (e *TagSvgEllipse) FontFamily(fontFamily string) (ref *TagSvgEllipse)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgEllipse) FontSize 

func (e *TagSvgEllipse) FontSize(fontSize interface{}) (ref *TagSvgEllipse)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgEllipse) FontSizeAdjust 

func (e *TagSvgEllipse) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgEllipse)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgEllipse) FontStretch 

func (e *TagSvgEllipse) FontStretch(fontStretch interface{}) (ref *TagSvgEllipse)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgEllipse) FontStyle 

func (e *TagSvgEllipse) FontStyle(fontStyle FontStyleRule) (ref *TagSvgEllipse)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgEllipse) FontVariant 

func (e *TagSvgEllipse) FontVariant(value interface{}) (ref *TagSvgEllipse)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgEllipse) FontWeight 

func (e *TagSvgEllipse) FontWeight(value interface{}) (ref *TagSvgEllipse)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgEllipse) Get 

func (e *TagSvgEllipse) Get() (el js.Value)

func (*TagSvgEllipse) Html 

func (e *TagSvgEllipse) Html(value string) (ref *TagSvgEllipse)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgEllipse) Id 

func (e *TagSvgEllipse) Id(id string) (ref *TagSvgEllipse)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgEllipse) ImageRendering 

func (e *TagSvgEllipse) ImageRendering(imageRendering string) (ref *TagSvgEllipse)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgEllipse) Init 

func (e *TagSvgEllipse) Init() (ref *TagSvgEllipse)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgEllipse) Lang 

func (e *TagSvgEllipse) Lang(value interface{}) (ref *TagSvgEllipse)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgEllipse) LetterSpacing 

func (e *TagSvgEllipse) LetterSpacing(value float64) (ref *TagSvgEllipse)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgEllipse) LightingColor 

func (e *TagSvgEllipse) LightingColor(value interface{}) (ref *TagSvgEllipse)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgEllipse) MarkerEnd 

func (e *TagSvgEllipse) MarkerEnd(value interface{}) (ref *TagSvgEllipse)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgEllipse) MarkerMid 

func (e *TagSvgEllipse) MarkerMid(value interface{}) (ref *TagSvgEllipse)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgEllipse) MarkerStart 

func (e *TagSvgEllipse) MarkerStart(value interface{}) (ref *TagSvgEllipse)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgEllipse) Mask 

func (e *TagSvgEllipse) Mask(value interface{}) (ref *TagSvgEllipse)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgEllipse) Opacity 

func (e *TagSvgEllipse) Opacity(value interface{}) (ref *TagSvgEllipse)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgEllipse) Overflow 

func (e *TagSvgEllipse) Overflow(value interface{}) (ref *TagSvgEllipse)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgEllipse) PaintOrder 

func (e *TagSvgEllipse) PaintOrder(value interface{}) (ref *TagSvgEllipse)

PaintOrder

English:

The paint-order attribute specifies the order that the fill, stroke, and markers of a given shape or text element are painted. 

Input:
  value: specifies the order that the fill, stroke, and markers
    const: SvgPaintOrder... (e.g. KSvgPaintOrderStroke)
    any other type: interface{}

Notes:
  * As a presentation attribute, paint-order can be used as a CSS property.

Português:

O atributo paint-order especifica a ordem em que o preenchimento, o traçado e os marcadores de uma determinada forma ou elemento de texto são pintados. 

Entrada:
  value: especifica a ordem em que o preenchimento, o traçado e os marcadores
    const: SvgPaintOrder... (e.g. KSvgPaintOrderStroke)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, paint-order pode ser usado como uma propriedade CSS.

func (*TagSvgEllipse) PathLength 

func (e *TagSvgEllipse) PathLength(value interface{}) (ref *TagSvgEllipse)

PathLength

English:

The pathLength attribute lets authors specify a total length for the path, in user units. This value is then used to calibrate the browser's distance calculations with those of the author, by scaling all distance computations using the ratio pathLength/(computed value of path length).

This can affect the actual rendered lengths of paths; including text paths, animation paths, and various stroke operations. Basically, all computations that require the length of the path. stroke-dasharray, for example, will assume the start of the path being 0 and the end point the value defined in the pathLength attribute.

Português:

O atributo pathLength permite que os autores especifiquem um comprimento total para o caminho, em unidades de usuário. Este valor é então usado para calibrar os cálculos de distância do navegador com os do autor, escalando todos os cálculos de distância usando a razão pathLength (valor calculado do comprimento do caminho).

Isso pode afetar os comprimentos reais dos caminhos renderizados; incluindo caminhos de texto, caminhos de animação e várias operações de traçado. Basicamente, todos os cálculos que exigem o comprimento do caminho. stroke-dasharray, por exemplo, assumirá o início do caminho sendo 0 e o ponto final o valor definido no atributo pathLength.

func (*TagSvgEllipse) PointerEvents 

func (e *TagSvgEllipse) PointerEvents(value interface{}) (ref *TagSvgEllipse)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgEllipse) Rx 

func (e *TagSvgEllipse) Rx(value float64) (ref *TagSvgEllipse)

Rx

English:

The rx attribute defines a radius on the x-axis.

Português:

O atributo rx define um raio no eixo x.

func (*TagSvgEllipse) Ry 

func (e *TagSvgEllipse) Ry(value float64) (ref *TagSvgEllipse)

Ry

English:

The ry attribute defines a radius on the y-axis.

Português:

O atributo ry define um raio no eixo y.

func (*TagSvgEllipse) ShapeRendering 

func (e *TagSvgEllipse) ShapeRendering(value interface{}) (ref *TagSvgEllipse)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgEllipse) StopColor 

func (e *TagSvgEllipse) StopColor(value interface{}) (ref *TagSvgEllipse)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgEllipse) StopOpacity 

func (e *TagSvgEllipse) StopOpacity(value interface{}) (ref *TagSvgEllipse)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgEllipse) Stroke 

func (e *TagSvgEllipse) Stroke(value interface{}) (ref *TagSvgEllipse)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgEllipse) StrokeDashOffset 

func (e *TagSvgEllipse) StrokeDashOffset(value interface{}) (ref *TagSvgEllipse)

StrokeDashOffset

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    float32: 0.1 = "10%"
    []float32: (e.g. []float32{0.04, 0.01, 0.02}) = "4% 1% 2%"
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    float32: 0.1 = "10%"
    []float32: (e.g. []float32{0.04, 0.01, 0.02}) = "4% 1% 2%"
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgEllipse) StrokeDasharray 

func (e *TagSvgEllipse) StrokeDasharray(value interface{}) (ref *TagSvgEllipse)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgEllipse) StrokeLineCap 

func (e *TagSvgEllipse) StrokeLineCap(value interface{}) (ref *TagSvgEllipse)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgEllipse) StrokeLineJoin 

func (e *TagSvgEllipse) StrokeLineJoin(value interface{}) (ref *TagSvgEllipse)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgEllipse) StrokeMiterLimit 

func (e *TagSvgEllipse) StrokeMiterLimit(value float64) (ref *TagSvgEllipse)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgEllipse) StrokeOpacity 

func (e *TagSvgEllipse) StrokeOpacity(value interface{}) (ref *TagSvgEllipse)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgEllipse) StrokeWidth 

func (e *TagSvgEllipse) StrokeWidth(value interface{}) (ref *TagSvgEllipse)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgEllipse) Style 

func (e *TagSvgEllipse) Style(value string) (ref *TagSvgEllipse)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgEllipse) Tabindex 

func (e *TagSvgEllipse) Tabindex(value int) (ref *TagSvgEllipse)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgEllipse) Text 

func (e *TagSvgEllipse) Text(value string) (ref *TagSvgEllipse)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgEllipse) TextAnchor 

func (e *TagSvgEllipse) TextAnchor(value interface{}) (ref *TagSvgEllipse)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgEllipse) TextDecoration 

func (e *TagSvgEllipse) TextDecoration(value interface{}) (ref *TagSvgEllipse)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgEllipse) TextRendering 

func (e *TagSvgEllipse) TextRendering(value interface{}) (ref *TagSvgEllipse)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgEllipse) Transform 

func (e *TagSvgEllipse) Transform(value interface{}) (ref *TagSvgEllipse)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgEllipse) UnicodeBidi 

func (e *TagSvgEllipse) UnicodeBidi(value interface{}) (ref *TagSvgEllipse)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgEllipse) VectorEffect 

func (e *TagSvgEllipse) VectorEffect(value interface{}) (ref *TagSvgEllipse)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgEllipse) Visibility 

func (e *TagSvgEllipse) Visibility(value interface{}) (ref *TagSvgEllipse)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgEllipse) WordSpacing 

func (e *TagSvgEllipse) WordSpacing(value interface{}) (ref *TagSvgEllipse)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgEllipse) WritingMode 

func (e *TagSvgEllipse) WritingMode(value interface{}) (ref *TagSvgEllipse)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgEllipse) XmlLang 

func (e *TagSvgEllipse) XmlLang(value interface{}) (ref *TagSvgEllipse)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

type TagSvgFeBlend 

type TagSvgFeBlend struct {
	// contains filtered or unexported fields
}

TagSvgFeBlend

English:

The <feBlend> SVG filter primitive composes two objects together ruled by a certain blending mode.

This is similar to what is known from image editing software when blending two layers. The mode is defined by the mode attribute.

Português:

A primitiva de filtro SVG <feBlend> compõe dois objetos juntos governados por um certo modo de mesclagem.

Isso é semelhante ao que é conhecido no software de edição de imagens ao misturar duas camadas. O modo é definido pelo atributo mode.

func (*TagSvgFeBlend) Append 

func (e *TagSvgFeBlend) Append(elements ...Compatible) (ref *TagSvgFeBlend)

func (*TagSvgFeBlend) AppendById 

func (e *TagSvgFeBlend) AppendById(appendId string) (ref *TagSvgFeBlend)

func (*TagSvgFeBlend) AppendToElement 

func (e *TagSvgFeBlend) AppendToElement(el js.Value) (ref *TagSvgFeBlend)

func (*TagSvgFeBlend) AppendToStage 

func (e *TagSvgFeBlend) AppendToStage() (ref *TagSvgFeBlend)

func (*TagSvgFeBlend) BaselineShift 

func (e *TagSvgFeBlend) BaselineShift(baselineShift interface{}) (ref *TagSvgFeBlend)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgFeBlend) Class 

func (e *TagSvgFeBlend) Class(class string) (ref *TagSvgFeBlend)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgFeBlend) ClipPath 

func (e *TagSvgFeBlend) ClipPath(clipPath string) (ref *TagSvgFeBlend)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgFeBlend) ClipRule 

func (e *TagSvgFeBlend) ClipRule(value interface{}) (ref *TagSvgFeBlend)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgFeBlend) Color 

func (e *TagSvgFeBlend) Color(value interface{}) (ref *TagSvgFeBlend)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgFeBlend) ColorInterpolation 

func (e *TagSvgFeBlend) ColorInterpolation(value interface{}) (ref *TagSvgFeBlend)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgFeBlend) ColorInterpolationFilters 

func (e *TagSvgFeBlend) ColorInterpolationFilters(value interface{}) (ref *TagSvgFeBlend)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgFeBlend) CreateElement 

func (e *TagSvgFeBlend) CreateElement() (ref *TagSvgFeBlend)

func (*TagSvgFeBlend) Cursor 

func (e *TagSvgFeBlend) Cursor(cursor SvgCursor) (ref *TagSvgFeBlend)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgFeBlend) Direction 

func (e *TagSvgFeBlend) Direction(direction SvgDirection) (ref *TagSvgFeBlend)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgFeBlend) Display 

func (e *TagSvgFeBlend) Display(value interface{}) (ref *TagSvgFeBlend)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgFeBlend) DominantBaseline 

func (e *TagSvgFeBlend) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgFeBlend)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgFeBlend) Fill 

func (e *TagSvgFeBlend) Fill(value interface{}) (ref *TagSvgFeBlend)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgFeBlend) FillOpacity 

func (e *TagSvgFeBlend) FillOpacity(value interface{}) (ref *TagSvgFeBlend)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgFeBlend) FillRule 

func (e *TagSvgFeBlend) FillRule(fillRule SvgFillRule) (ref *TagSvgFeBlend)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgFeBlend) Filter 

func (e *TagSvgFeBlend) Filter(filter string) (ref *TagSvgFeBlend)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgFeBlend) FloodColor 

func (e *TagSvgFeBlend) FloodColor(floodColor interface{}) (ref *TagSvgFeBlend)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgFeBlend) FloodOpacity 

func (e *TagSvgFeBlend) FloodOpacity(floodOpacity float64) (ref *TagSvgFeBlend)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgFeBlend) FontFamily 

func (e *TagSvgFeBlend) FontFamily(fontFamily string) (ref *TagSvgFeBlend)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgFeBlend) FontSize 

func (e *TagSvgFeBlend) FontSize(fontSize interface{}) (ref *TagSvgFeBlend)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgFeBlend) FontSizeAdjust 

func (e *TagSvgFeBlend) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgFeBlend)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgFeBlend) FontStretch 

func (e *TagSvgFeBlend) FontStretch(fontStretch interface{}) (ref *TagSvgFeBlend)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgFeBlend) FontStyle 

func (e *TagSvgFeBlend) FontStyle(fontStyle FontStyleRule) (ref *TagSvgFeBlend)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgFeBlend) FontVariant 

func (e *TagSvgFeBlend) FontVariant(value interface{}) (ref *TagSvgFeBlend)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgFeBlend) FontWeight 

func (e *TagSvgFeBlend) FontWeight(value interface{}) (ref *TagSvgFeBlend)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgFeBlend) Get 

func (e *TagSvgFeBlend) Get() (el js.Value)

func (*TagSvgFeBlend) Height 

func (e *TagSvgFeBlend) Height(height interface{}) (ref *TagSvgFeBlend)

Height

English: 

The height attribute defines the vertical length of an element in the user coordinate system.
     float32: 1.0 = "100%"
     any other type: interface{}

Português: 

O atributo height define o comprimento vertical de um elemento no sistema de coordenadas do usuário.
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

func (*TagSvgFeBlend) Html 

func (e *TagSvgFeBlend) Html(value string) (ref *TagSvgFeBlend)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgFeBlend) Id 

func (e *TagSvgFeBlend) Id(id string) (ref *TagSvgFeBlend)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgFeBlend) ImageRendering 

func (e *TagSvgFeBlend) ImageRendering(imageRendering string) (ref *TagSvgFeBlend)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgFeBlend) In 

func (e *TagSvgFeBlend) In(in interface{}) (ref *TagSvgFeBlend)

In

English: 

The in attribute identifies input for the given filter primitive.

 Input:
   in: identifies input for the given filter primitive.
     KSvgIn... (e.g. KSvgInSourceAlpha)
     any other type: interface{}

The value can be either one of the six keywords defined below, or a string which matches a previous result attribute value within the same <filter> element. If no value is provided and this is the first filter primitive, then this filter primitive will use SourceGraphic as its input. If no value is provided and this is a subsequent filter primitive, then this filter primitive will use the result from the previous filter primitive as its input.

If the value for result appears multiple times within a given <filter> element, then a reference to that result will use the closest preceding filter primitive with the given value for attribute result.

Portuguese 

O atributo in identifica à entrada para a primitiva de filtro fornecida.

 Entrada:
   in: identifica à entrada para a primitiva de filtro fornecida.
     KSvgIn... (e.g. KSvgInSourceAlpha)
     qualquer outro tipo: interface{}

O valor pode ser uma das seis palavras-chave definidas abaixo ou uma string que corresponda a um valor de atributo de resultado anterior dentro do mesmo elemento <filter>. Se nenhum valor for fornecido e esta for a primeira primitiva de filtro, essa primitiva de filtro usará SourceGraphic como sua entrada. Se nenhum valor for fornecido e esta for uma primitiva de filtro subsequente, essa primitiva de filtro usará o resultado da primitiva de filtro anterior como sua entrada.

Se o valor do resultado aparecer várias vezes em um determinado elemento <filter>, uma referência à esse resultado usará a primitiva de filtro anterior mais próxima com o valor fornecido para o resultado do atributo.

func (*TagSvgFeBlend) In2 

func (e *TagSvgFeBlend) In2(in2 interface{}) (ref *TagSvgFeBlend)

In2

English: 

The in2 attribute identifies the second input for the given filter primitive. It works exactly like the in
attribute.

 Input:
   in2: identifies the second input for the given filter primitive.
     KSvgIn2... (e.g. KSvgIn2SourceAlpha)
     string: url(#myClip)
     any other type: interface{}

Portuguese 

O atributo in2 identifica a segunda entrada para a primitiva de filtro fornecida. Funciona exatamente como o
atributo in.

 Entrada:
   in2: identifica a segunda entrada para a primitiva de filtro fornecida.
     KSvgIn2... (ex. KSvgIn2SourceAlpha)
     string: url(#myClip)
     qualquer outro tipo: interface{}

func (*TagSvgFeBlend) Init 

func (e *TagSvgFeBlend) Init() (ref *TagSvgFeBlend)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgFeBlend) Lang 

func (e *TagSvgFeBlend) Lang(value interface{}) (ref *TagSvgFeBlend)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgFeBlend) LetterSpacing 

func (e *TagSvgFeBlend) LetterSpacing(value float64) (ref *TagSvgFeBlend)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgFeBlend) LightingColor 

func (e *TagSvgFeBlend) LightingColor(value interface{}) (ref *TagSvgFeBlend)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgFeBlend) MarkerEnd 

func (e *TagSvgFeBlend) MarkerEnd(value interface{}) (ref *TagSvgFeBlend)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgFeBlend) MarkerMid 

func (e *TagSvgFeBlend) MarkerMid(value interface{}) (ref *TagSvgFeBlend)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgFeBlend) MarkerStart 

func (e *TagSvgFeBlend) MarkerStart(value interface{}) (ref *TagSvgFeBlend)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgFeBlend) Mask 

func (e *TagSvgFeBlend) Mask(value interface{}) (ref *TagSvgFeBlend)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgFeBlend) Mode 

func (e *TagSvgFeBlend) Mode(value interface{}) (ref *TagSvgFeBlend)

Mode

English:

The mode attribute defines the blending mode on the <feBlend> filter primitive. 

Input:
  value: defines the blending mode
    const KSvgMode... (e.g. KSvgModeNormal)
    any other type: interface{}

Português:

O atributo mode define o modo de mesclagem na primitiva de filtro <feBlend>. 

Entrada:
  value: define o modo de mesclagem
    const KSvgMode... (ex. KSvgModeNormal)
    qualquer outro tipo: interface{}

todo: exemplos: https://developer.mozilla.org/en-US/docs/Web/CSS/blend-mode

func (*TagSvgFeBlend) Opacity 

func (e *TagSvgFeBlend) Opacity(value interface{}) (ref *TagSvgFeBlend)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgFeBlend) Overflow 

func (e *TagSvgFeBlend) Overflow(value interface{}) (ref *TagSvgFeBlend)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgFeBlend) PointerEvents 

func (e *TagSvgFeBlend) PointerEvents(value interface{}) (ref *TagSvgFeBlend)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgFeBlend) Result 

func (e *TagSvgFeBlend) Result(value interface{}) (ref *TagSvgFeBlend)

Result

English:

The result attribute defines the assigned name for this filter primitive. If supplied, then graphics that result from processing this filter primitive can be referenced by an in attribute on a subsequent filter primitive within the same <filter> element. If no value is provided, the output will only be available for re-use as the implicit input into the next filter primitive if that filter primitive provides no value for its in attribute.

Português:

O atributo result define o nome atribuído para esta primitiva de filtro. Se fornecido, os gráficos resultantes do processamento dessa primitiva de filtro podem ser referenciados por um atributo in em uma primitiva de filtro subsequente dentro do mesmo elemento <filter>. Se nenhum valor for fornecido, a saída só estará disponível para reutilização como entrada implícita na próxima primitiva de filtro se essa primitiva de filtro não fornecer valor para seu atributo in.

func (*TagSvgFeBlend) ShapeRendering 

func (e *TagSvgFeBlend) ShapeRendering(value interface{}) (ref *TagSvgFeBlend)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgFeBlend) StopColor 

func (e *TagSvgFeBlend) StopColor(value interface{}) (ref *TagSvgFeBlend)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgFeBlend) StopOpacity 

func (e *TagSvgFeBlend) StopOpacity(value interface{}) (ref *TagSvgFeBlend)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgFeBlend) Stroke 

func (e *TagSvgFeBlend) Stroke(value interface{}) (ref *TagSvgFeBlend)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgFeBlend) StrokeDasharray 

func (e *TagSvgFeBlend) StrokeDasharray(value interface{}) (ref *TagSvgFeBlend)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgFeBlend) StrokeLineCap 

func (e *TagSvgFeBlend) StrokeLineCap(value interface{}) (ref *TagSvgFeBlend)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgFeBlend) StrokeLineJoin 

func (e *TagSvgFeBlend) StrokeLineJoin(value interface{}) (ref *TagSvgFeBlend)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgFeBlend) StrokeMiterLimit 

func (e *TagSvgFeBlend) StrokeMiterLimit(value float64) (ref *TagSvgFeBlend)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgFeBlend) StrokeOpacity 

func (e *TagSvgFeBlend) StrokeOpacity(value interface{}) (ref *TagSvgFeBlend)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgFeBlend) StrokeWidth 

func (e *TagSvgFeBlend) StrokeWidth(value interface{}) (ref *TagSvgFeBlend)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeBlend) Style 

func (e *TagSvgFeBlend) Style(value string) (ref *TagSvgFeBlend)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgFeBlend) Tabindex 

func (e *TagSvgFeBlend) Tabindex(value int) (ref *TagSvgFeBlend)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgFeBlend) Text 

func (e *TagSvgFeBlend) Text(value string) (ref *TagSvgFeBlend)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgFeBlend) TextAnchor 

func (e *TagSvgFeBlend) TextAnchor(value interface{}) (ref *TagSvgFeBlend)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgFeBlend) TextDecoration 

func (e *TagSvgFeBlend) TextDecoration(value interface{}) (ref *TagSvgFeBlend)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgFeBlend) TextRendering 

func (e *TagSvgFeBlend) TextRendering(value interface{}) (ref *TagSvgFeBlend)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgFeBlend) Transform 

func (e *TagSvgFeBlend) Transform(value interface{}) (ref *TagSvgFeBlend)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgFeBlend) UnicodeBidi 

func (e *TagSvgFeBlend) UnicodeBidi(value interface{}) (ref *TagSvgFeBlend)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgFeBlend) VectorEffect 

func (e *TagSvgFeBlend) VectorEffect(value interface{}) (ref *TagSvgFeBlend)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgFeBlend) Visibility 

func (e *TagSvgFeBlend) Visibility(value interface{}) (ref *TagSvgFeBlend)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgFeBlend) Width 

func (e *TagSvgFeBlend) Width(value interface{}) (ref *TagSvgFeBlend)

Width

English:

The width attribute defines the horizontal length of an element in the user coordinate system. 

Input:
  value: the horizontal length of an element
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo largura define o comprimento horizontal de um elemento no sistema de coordenadas do usuário. 

Entrada:
  value: o comprimento horizontal de um elemento
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeBlend) WordSpacing 

func (e *TagSvgFeBlend) WordSpacing(value interface{}) (ref *TagSvgFeBlend)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgFeBlend) WritingMode 

func (e *TagSvgFeBlend) WritingMode(value interface{}) (ref *TagSvgFeBlend)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgFeBlend) X 

func (e *TagSvgFeBlend) X(value interface{}) (ref *TagSvgFeBlend)

X

English:

The x attribute defines an x-axis coordinate in the user coordinate system. 

Input:
  value: defines an x-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo x define uma coordenada do eixo x no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo x
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgFeBlend) XmlLang 

func (e *TagSvgFeBlend) XmlLang(value interface{}) (ref *TagSvgFeBlend)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

func (*TagSvgFeBlend) Y 

func (e *TagSvgFeBlend) Y(value interface{}) (ref *TagSvgFeBlend)

Y

English:

The y attribute defines an y-axis coordinate in the user coordinate system. 

Input:
  value: defines an y-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo y define uma coordenada do eixo y no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo y
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

type TagSvgFeColorMatrix 

type TagSvgFeColorMatrix struct {
	// contains filtered or unexported fields
}

TagSvgFeColorMatrix

English:

The <feColorMatrix> SVG filter element changes colors based on a transformation matrix. Every pixel's color value [R,G,B,A] is matrix multiplied by a 5 by 5 color matrix to create new color [R',G',B',A']. 

 Notes:
   * The prime symbol ' is used in mathematics indicate the result of a transformation.

| R' |     | r1 r2 r3 r4 r5 |   | R |
| G' |     | g1 g2 g3 g4 g5 |   | G |
| B' |  =  | b1 b2 b3 b4 b5 | * | B |
| A' |     | a1 a2 a3 a4 a5 |   | A |
| 1  |     |  0  0  0  0  1 |   | 1 |

In simplified terms, below is how each color channel in the new pixel is calculated. The last row is ignored because its values are constant. 

R' = r1*R + r2*G + r3*B + r4*A + r5
G' = g1*R + g2*G + g3*B + g4*A + g5
B' = b1*R + b2*G + b3*B + b4*A + b5
A' = a1*R + a2*G + a3*B + a4*A + a5

Take the amount of red in the new pixel, or R':

It is the sum of:

  • r1 times the old pixel's red R,
  • r2 times the old pixel's green G,
  • r3 times of the old pixel's blue B,
  • r4 times the old pixel's alpha A,
  • plus a shift r5.

These specified amounts can be any real number, though the final R' will be clamped between 0 and 1. The same goes for G', B', and A'. 

R'      =      r1 * R      +        r2 * G      +       r3 * B      +       r4 * A       +       r5
New red = [ r1 * old red ] + [ r2 * old green ] + [ r3 * old Blue ] + [ r4 * old Alpha ] + [ shift of r5 ]

If, say, we want to make a completely black image redder, we can make the r5 a positive real number x, boosting the redness on every pixel of the new image by x.

An identity matrix looks like this: 

     R G B A W
R' | 1 0 0 0 0 |
G' | 0 1 0 0 0 |
B' | 0 0 1 0 0 |
A' | 0 0 0 1 0 |

In it, every new value is exactly 1 times its old value, with nothing else added. It is recommended to start manipulating the matrix from here.

Português:

O elemento de filtro SVG <feColorMatrix> altera as cores com base em uma matriz de transformação. O valor de cor de cada pixel [R,G,B,A] é uma matriz multiplicada por uma matriz de cores de 5 por 5 para criar uma nova cor [R',G',B',A']. 

 Notas:
   * O símbolo primo ' é usado em matemática para indicar o resultado de uma transformação.

| R' |     | r1 r2 r3 r4 r5 |   | R |
| G' |     | g1 g2 g3 g4 g5 |   | G |
| B' |  =  | b1 b2 b3 b4 b5 | * | B |
| A' |     | a1 a2 a3 a4 a5 |   | A |
| 1  |     |  0  0  0  0  1 |   | 1 |

Em termos simplificados, abaixo está como cada canal de cor no novo pixel é calculado. A última linha é ignorada porque seus valores são constantes. 

R' = r1*R + r2*G + r3*B + r4*A + r5
G' = g1*R + g2*G + g3*B + g4*A + g5
B' = b1*R + b2*G + b3*B + b4*A + b5
A' = a1*R + a2*G + a3*B + a4*A + a5

Pegue a quantidade de vermelho no novo pixel, ou R':

É a soma de:

  • r1 vezes o antigo pixel vermelho, R,
  • r2 vezes o antigo pixel verde, G,
  • r3 vezes o antigo pixel azul, B,
  • r4 vezes o antigo pixel alpha, A,
  • mais um turno r5.

Esses valores especificados podem ser qualquer número real, embora o R' final seja fixado entre 0 e 1. O mesmo vale para G', B' e A'. 

R'      =      r1 * R      +        r2 * G      +       r3 * B      +       r4 * A       +       r5
New red = [ r1 * old red ] + [ r2 * old green ] + [ r3 * old Blue ] + [ r4 * old Alpha ] + [ shift of r5 ]

Se, digamos, queremos tornar uma imagem completamente preta mais vermelha, podemos tornar o r5 um número real positivo x, aumentando a vermelhidão em cada pixel da nova imagem em x.

Uma matriz identidade fica assim: 

     R G B A W
R' | 1 0 0 0 0 |
G' | 0 1 0 0 0 |
B' | 0 0 1 0 0 |
A' | 0 0 0 1 0 |

Nele, cada novo valor é exatamente 1 vez seu valor antigo, sem mais nada adicionado. Recomenda-se começar a manipular a matriz a partir daqui.

func (*TagSvgFeColorMatrix) Append 

func (e *TagSvgFeColorMatrix) Append(elements ...Compatible) (ref *TagSvgFeColorMatrix)

func (*TagSvgFeColorMatrix) AppendById 

func (e *TagSvgFeColorMatrix) AppendById(appendId string) (ref *TagSvgFeColorMatrix)

func (*TagSvgFeColorMatrix) AppendToElement 

func (e *TagSvgFeColorMatrix) AppendToElement(el js.Value) (ref *TagSvgFeColorMatrix)

func (*TagSvgFeColorMatrix) AppendToStage 

func (e *TagSvgFeColorMatrix) AppendToStage() (ref *TagSvgFeColorMatrix)

func (*TagSvgFeColorMatrix) BaselineShift 

func (e *TagSvgFeColorMatrix) BaselineShift(baselineShift interface{}) (ref *TagSvgFeColorMatrix)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgFeColorMatrix) Class 

func (e *TagSvgFeColorMatrix) Class(class string) (ref *TagSvgFeColorMatrix)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgFeColorMatrix) ClipPath 

func (e *TagSvgFeColorMatrix) ClipPath(clipPath string) (ref *TagSvgFeColorMatrix)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgFeColorMatrix) ClipRule 

func (e *TagSvgFeColorMatrix) ClipRule(value interface{}) (ref *TagSvgFeColorMatrix)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgFeColorMatrix) Color 

func (e *TagSvgFeColorMatrix) Color(value interface{}) (ref *TagSvgFeColorMatrix)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgFeColorMatrix) ColorInterpolation 

func (e *TagSvgFeColorMatrix) ColorInterpolation(value interface{}) (ref *TagSvgFeColorMatrix)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgFeColorMatrix) ColorInterpolationFilters 

func (e *TagSvgFeColorMatrix) ColorInterpolationFilters(value interface{}) (ref *TagSvgFeColorMatrix)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgFeColorMatrix) CreateElement 

func (e *TagSvgFeColorMatrix) CreateElement() (ref *TagSvgFeColorMatrix)

func (*TagSvgFeColorMatrix) Cursor 

func (e *TagSvgFeColorMatrix) Cursor(cursor SvgCursor) (ref *TagSvgFeColorMatrix)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgFeColorMatrix) Direction 

func (e *TagSvgFeColorMatrix) Direction(direction SvgDirection) (ref *TagSvgFeColorMatrix)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgFeColorMatrix) Display 

func (e *TagSvgFeColorMatrix) Display(value interface{}) (ref *TagSvgFeColorMatrix)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgFeColorMatrix) DominantBaseline 

func (e *TagSvgFeColorMatrix) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgFeColorMatrix)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgFeColorMatrix) Fill 

func (e *TagSvgFeColorMatrix) Fill(value interface{}) (ref *TagSvgFeColorMatrix)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgFeColorMatrix) FillOpacity 

func (e *TagSvgFeColorMatrix) FillOpacity(value interface{}) (ref *TagSvgFeColorMatrix)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgFeColorMatrix) FillRule 

func (e *TagSvgFeColorMatrix) FillRule(fillRule SvgFillRule) (ref *TagSvgFeColorMatrix)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgFeColorMatrix) Filter 

func (e *TagSvgFeColorMatrix) Filter(filter string) (ref *TagSvgFeColorMatrix)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgFeColorMatrix) FloodColor 

func (e *TagSvgFeColorMatrix) FloodColor(floodColor interface{}) (ref *TagSvgFeColorMatrix)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgFeColorMatrix) FloodOpacity 

func (e *TagSvgFeColorMatrix) FloodOpacity(floodOpacity float64) (ref *TagSvgFeColorMatrix)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgFeColorMatrix) FontFamily 

func (e *TagSvgFeColorMatrix) FontFamily(fontFamily string) (ref *TagSvgFeColorMatrix)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgFeColorMatrix) FontSize 

func (e *TagSvgFeColorMatrix) FontSize(fontSize interface{}) (ref *TagSvgFeColorMatrix)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgFeColorMatrix) FontSizeAdjust 

func (e *TagSvgFeColorMatrix) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgFeColorMatrix)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgFeColorMatrix) FontStretch 

func (e *TagSvgFeColorMatrix) FontStretch(fontStretch interface{}) (ref *TagSvgFeColorMatrix)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgFeColorMatrix) FontStyle 

func (e *TagSvgFeColorMatrix) FontStyle(fontStyle FontStyleRule) (ref *TagSvgFeColorMatrix)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgFeColorMatrix) FontVariant 

func (e *TagSvgFeColorMatrix) FontVariant(value interface{}) (ref *TagSvgFeColorMatrix)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgFeColorMatrix) FontWeight 

func (e *TagSvgFeColorMatrix) FontWeight(value interface{}) (ref *TagSvgFeColorMatrix)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgFeColorMatrix) Get 

func (e *TagSvgFeColorMatrix) Get() (el js.Value)

func (*TagSvgFeColorMatrix) Height 

func (e *TagSvgFeColorMatrix) Height(height interface{}) (ref *TagSvgFeColorMatrix)

Height

English: 

The height attribute defines the vertical length of an element in the user coordinate system.
     float32: 1.0 = "100%"
     any other type: interface{}

Português: 

O atributo height define o comprimento vertical de um elemento no sistema de coordenadas do usuário.
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

func (*TagSvgFeColorMatrix) Html 

func (e *TagSvgFeColorMatrix) Html(value string) (ref *TagSvgFeColorMatrix)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgFeColorMatrix) Id 

func (e *TagSvgFeColorMatrix) Id(id string) (ref *TagSvgFeColorMatrix)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgFeColorMatrix) ImageRendering 

func (e *TagSvgFeColorMatrix) ImageRendering(imageRendering string) (ref *TagSvgFeColorMatrix)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgFeColorMatrix) In 

func (e *TagSvgFeColorMatrix) In(in interface{}) (ref *TagSvgFeColorMatrix)

In

English: 

The in attribute identifies input for the given filter primitive.

 Input:
   in: identifies input for the given filter primitive.
     KSvgIn... (e.g. KSvgInSourceAlpha)
     any other type: interface{}

The value can be either one of the six keywords defined below, or a string which matches a previous result attribute value within the same <filter> element. If no value is provided and this is the first filter primitive, then this filter primitive will use SourceGraphic as its input. If no value is provided and this is a subsequent filter primitive, then this filter primitive will use the result from the previous filter primitive as its input.

If the value for result appears multiple times within a given <filter> element, then a reference to that result will use the closest preceding filter primitive with the given value for attribute result.

Portuguese 

O atributo in identifica à entrada para a primitiva de filtro fornecida.

 Entrada:
   in: identifica à entrada para a primitiva de filtro fornecida.
     KSvgIn... (e.g. KSvgInSourceAlpha)
     qualquer outro tipo: interface{}

O valor pode ser uma das seis palavras-chave definidas abaixo ou uma string que corresponda a um valor de atributo de resultado anterior dentro do mesmo elemento <filter>. Se nenhum valor for fornecido e esta for a primeira primitiva de filtro, essa primitiva de filtro usará SourceGraphic como sua entrada. Se nenhum valor for fornecido e esta for uma primitiva de filtro subsequente, essa primitiva de filtro usará o resultado da primitiva de filtro anterior como sua entrada.

Se o valor do resultado aparecer várias vezes em um determinado elemento <filter>, uma referência à esse resultado usará a primitiva de filtro anterior mais próxima com o valor fornecido para o resultado do atributo.

func (*TagSvgFeColorMatrix) Init 

func (e *TagSvgFeColorMatrix) Init() (ref *TagSvgFeColorMatrix)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgFeColorMatrix) Lang 

func (e *TagSvgFeColorMatrix) Lang(value interface{}) (ref *TagSvgFeColorMatrix)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgFeColorMatrix) LetterSpacing 

func (e *TagSvgFeColorMatrix) LetterSpacing(value float64) (ref *TagSvgFeColorMatrix)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgFeColorMatrix) LightingColor 

func (e *TagSvgFeColorMatrix) LightingColor(value interface{}) (ref *TagSvgFeColorMatrix)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgFeColorMatrix) MarkerEnd 

func (e *TagSvgFeColorMatrix) MarkerEnd(value interface{}) (ref *TagSvgFeColorMatrix)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgFeColorMatrix) MarkerMid 

func (e *TagSvgFeColorMatrix) MarkerMid(value interface{}) (ref *TagSvgFeColorMatrix)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgFeColorMatrix) MarkerStart 

func (e *TagSvgFeColorMatrix) MarkerStart(value interface{}) (ref *TagSvgFeColorMatrix)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgFeColorMatrix) Mask 

func (e *TagSvgFeColorMatrix) Mask(value interface{}) (ref *TagSvgFeColorMatrix)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgFeColorMatrix) Opacity 

func (e *TagSvgFeColorMatrix) Opacity(value interface{}) (ref *TagSvgFeColorMatrix)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgFeColorMatrix) Overflow 

func (e *TagSvgFeColorMatrix) Overflow(value interface{}) (ref *TagSvgFeColorMatrix)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgFeColorMatrix) PointerEvents 

func (e *TagSvgFeColorMatrix) PointerEvents(value interface{}) (ref *TagSvgFeColorMatrix)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgFeColorMatrix) Result 

func (e *TagSvgFeColorMatrix) Result(value interface{}) (ref *TagSvgFeColorMatrix)

Result

English:

The result attribute defines the assigned name for this filter primitive. If supplied, then graphics that result from processing this filter primitive can be referenced by an in attribute on a subsequent filter primitive within the same <filter> element. If no value is provided, the output will only be available for re-use as the implicit input into the next filter primitive if that filter primitive provides no value for its in attribute.

Português:

O atributo result define o nome atribuído para esta primitiva de filtro. Se fornecido, os gráficos resultantes do processamento dessa primitiva de filtro podem ser referenciados por um atributo in em uma primitiva de filtro subsequente dentro do mesmo elemento <filter>. Se nenhum valor for fornecido, a saída só estará disponível para reutilização como entrada implícita na próxima primitiva de filtro se essa primitiva de filtro não fornecer valor para seu atributo in.

func (*TagSvgFeColorMatrix) ShapeRendering 

func (e *TagSvgFeColorMatrix) ShapeRendering(value interface{}) (ref *TagSvgFeColorMatrix)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgFeColorMatrix) StopColor 

func (e *TagSvgFeColorMatrix) StopColor(value interface{}) (ref *TagSvgFeColorMatrix)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgFeColorMatrix) StopOpacity 

func (e *TagSvgFeColorMatrix) StopOpacity(value interface{}) (ref *TagSvgFeColorMatrix)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgFeColorMatrix) Stroke 

func (e *TagSvgFeColorMatrix) Stroke(value interface{}) (ref *TagSvgFeColorMatrix)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgFeColorMatrix) StrokeDasharray 

func (e *TagSvgFeColorMatrix) StrokeDasharray(value interface{}) (ref *TagSvgFeColorMatrix)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgFeColorMatrix) StrokeLineCap 

func (e *TagSvgFeColorMatrix) StrokeLineCap(value interface{}) (ref *TagSvgFeColorMatrix)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgFeColorMatrix) StrokeLineJoin 

func (e *TagSvgFeColorMatrix) StrokeLineJoin(value interface{}) (ref *TagSvgFeColorMatrix)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgFeColorMatrix) StrokeMiterLimit 

func (e *TagSvgFeColorMatrix) StrokeMiterLimit(value float64) (ref *TagSvgFeColorMatrix)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgFeColorMatrix) StrokeOpacity 

func (e *TagSvgFeColorMatrix) StrokeOpacity(value interface{}) (ref *TagSvgFeColorMatrix)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgFeColorMatrix) StrokeWidth 

func (e *TagSvgFeColorMatrix) StrokeWidth(value interface{}) (ref *TagSvgFeColorMatrix)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeColorMatrix) Style 

func (e *TagSvgFeColorMatrix) Style(value string) (ref *TagSvgFeColorMatrix)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgFeColorMatrix) Tabindex 

func (e *TagSvgFeColorMatrix) Tabindex(value int) (ref *TagSvgFeColorMatrix)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgFeColorMatrix) Text 

func (e *TagSvgFeColorMatrix) Text(value string) (ref *TagSvgFeColorMatrix)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgFeColorMatrix) TextAnchor 

func (e *TagSvgFeColorMatrix) TextAnchor(value interface{}) (ref *TagSvgFeColorMatrix)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgFeColorMatrix) TextDecoration 

func (e *TagSvgFeColorMatrix) TextDecoration(value interface{}) (ref *TagSvgFeColorMatrix)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgFeColorMatrix) TextRendering 

func (e *TagSvgFeColorMatrix) TextRendering(value interface{}) (ref *TagSvgFeColorMatrix)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgFeColorMatrix) Transform 

func (e *TagSvgFeColorMatrix) Transform(value interface{}) (ref *TagSvgFeColorMatrix)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgFeColorMatrix) Type 

func (e *TagSvgFeColorMatrix) Type(value interface{}) (ref *TagSvgFeColorMatrix)

Type

English:

Indicates the type of matrix operation.

The keyword matrix indicates that a full 5x4 matrix of values will be provided. The other keywords represent convenience shortcuts to allow commonly used color operations to be performed without specifying a complete matrix. 

Input:
  value: type of matrix operation
    const: KSvgTypeFeColorMatrix... (e.g. KSvgTypeFeColorMatrixSaturate)
    any other type: interface{}

Português:

Indica o tipo de operação de matriz.

A matriz de palavras-chave indica que uma matriz de valores 5x4 completa será fornecida. As outras palavras-chave representam atalhos de conveniência para permitir que as operações de cores comumente usadas sejam executadas sem especificar uma matriz completa. 

Entrada:
  value: tipo de operação matricial
    const: KSvgTypeFeColorMatrix... (e.g. KSvgTypeFeColorMatrixSaturate)
    qualquer outro tipo: interface{}

func (*TagSvgFeColorMatrix) UnicodeBidi 

func (e *TagSvgFeColorMatrix) UnicodeBidi(value interface{}) (ref *TagSvgFeColorMatrix)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgFeColorMatrix) Values 

func (e *TagSvgFeColorMatrix) Values(value interface{}) (ref *TagSvgFeColorMatrix)

Values

English:

The values attribute has different meanings, depending upon the context where it's used, either it defines a sequence of values used over the course of an animation, or it's a list of numbers for a color matrix, which is interpreted differently depending on the type of color change to be performed. 

Input:
  value: list of values
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1),rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0%, 10%"
    []float64: []float64{0.0, 10.0} = "0, 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s, 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    any other type: interface{}

Português:

O atributo values tem significados diferentes, dependendo do contexto em que é usado, ou define uma sequência de valores usados ao longo de uma animação, ou é uma lista de números para uma matriz de cores, que é interpretada de forma diferente dependendo do tipo de mudança de cor a ser executada. 

Input:
  value: lista de valores
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1),rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0%, 10%"
    []float64: []float64{0.0, 10.0} = "0, 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s, 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    any other type: interface{}

func (*TagSvgFeColorMatrix) VectorEffect 

func (e *TagSvgFeColorMatrix) VectorEffect(value interface{}) (ref *TagSvgFeColorMatrix)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgFeColorMatrix) Visibility 

func (e *TagSvgFeColorMatrix) Visibility(value interface{}) (ref *TagSvgFeColorMatrix)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgFeColorMatrix) Width 

func (e *TagSvgFeColorMatrix) Width(value interface{}) (ref *TagSvgFeColorMatrix)

Width

English:

The width attribute defines the horizontal length of an element in the user coordinate system. 

Input:
  value: the horizontal length of an element
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo largura define o comprimento horizontal de um elemento no sistema de coordenadas do usuário. 

Entrada:
  value: o comprimento horizontal de um elemento
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeColorMatrix) WordSpacing 

func (e *TagSvgFeColorMatrix) WordSpacing(value interface{}) (ref *TagSvgFeColorMatrix)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgFeColorMatrix) WritingMode 

func (e *TagSvgFeColorMatrix) WritingMode(value interface{}) (ref *TagSvgFeColorMatrix)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgFeColorMatrix) X 

func (e *TagSvgFeColorMatrix) X(value interface{}) (ref *TagSvgFeColorMatrix)

X

English:

The x attribute defines an x-axis coordinate in the user coordinate system. 

Input:
  value: defines an x-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo x define uma coordenada do eixo x no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo x
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgFeColorMatrix) XmlLang 

func (e *TagSvgFeColorMatrix) XmlLang(value interface{}) (ref *TagSvgFeColorMatrix)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

func (*TagSvgFeColorMatrix) Y 

func (e *TagSvgFeColorMatrix) Y(value interface{}) (ref *TagSvgFeColorMatrix)

Y

English:

The y attribute defines an y-axis coordinate in the user coordinate system. 

Input:
  value: defines an y-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo y define uma coordenada do eixo y no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo y
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

type TagSvgFeComponentTransfer 

type TagSvgFeComponentTransfer struct {
	// contains filtered or unexported fields
}

TagSvgFeComponentTransfer

English:

The <feComponentTransfer> SVG filter primitive performs color-component-wise remapping of data for each pixel.

It allows operations like brightness adjustment, contrast adjustment, color balance or thresholding.

The calculations are performed on non-premultiplied color values. The colors are modified by changing each channel (R, G, B, and A) to the result of what the children <feFuncR>, <feFuncB>, <feFuncG>, and <feFuncA> return.

Português:

A primitiva de filtro SVG <feComponentTransfer> executa o remapeamento de dados por componente de cor para cada pixel.

Permite operações como ajuste de brilho, ajuste de contraste, equilíbrio de cores ou limiar.

Os cálculos são executados em valores de cores não pré-multiplicados. As cores são modificadas alterando cada canal (R, G, B e A) para o resultado do que os filhos <feFuncR>, <feFuncB>, <feFuncG> e <feFuncA> retornam.

func (*TagSvgFeComponentTransfer) Append 

func (e *TagSvgFeComponentTransfer) Append(elements ...Compatible) (ref *TagSvgFeComponentTransfer)

func (*TagSvgFeComponentTransfer) AppendById 

func (e *TagSvgFeComponentTransfer) AppendById(appendId string) (ref *TagSvgFeComponentTransfer)

func (*TagSvgFeComponentTransfer) AppendToElement 

func (e *TagSvgFeComponentTransfer) AppendToElement(el js.Value) (ref *TagSvgFeComponentTransfer)

func (*TagSvgFeComponentTransfer) AppendToStage 

func (e *TagSvgFeComponentTransfer) AppendToStage() (ref *TagSvgFeComponentTransfer)

func (*TagSvgFeComponentTransfer) BaselineShift 

func (e *TagSvgFeComponentTransfer) BaselineShift(baselineShift interface{}) (ref *TagSvgFeComponentTransfer)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgFeComponentTransfer) Class 

func (e *TagSvgFeComponentTransfer) Class(class string) (ref *TagSvgFeComponentTransfer)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgFeComponentTransfer) ClipPath 

func (e *TagSvgFeComponentTransfer) ClipPath(clipPath string) (ref *TagSvgFeComponentTransfer)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgFeComponentTransfer) ClipRule 

func (e *TagSvgFeComponentTransfer) ClipRule(value interface{}) (ref *TagSvgFeComponentTransfer)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgFeComponentTransfer) Color 

func (e *TagSvgFeComponentTransfer) Color(value interface{}) (ref *TagSvgFeComponentTransfer)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgFeComponentTransfer) ColorInterpolation 

func (e *TagSvgFeComponentTransfer) ColorInterpolation(value interface{}) (ref *TagSvgFeComponentTransfer)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgFeComponentTransfer) ColorInterpolationFilters 

func (e *TagSvgFeComponentTransfer) ColorInterpolationFilters(value interface{}) (ref *TagSvgFeComponentTransfer)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgFeComponentTransfer) CreateElement 

func (e *TagSvgFeComponentTransfer) CreateElement() (ref *TagSvgFeComponentTransfer)

func (*TagSvgFeComponentTransfer) Cursor 

func (e *TagSvgFeComponentTransfer) Cursor(cursor SvgCursor) (ref *TagSvgFeComponentTransfer)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgFeComponentTransfer) Direction 

func (e *TagSvgFeComponentTransfer) Direction(direction SvgDirection) (ref *TagSvgFeComponentTransfer)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgFeComponentTransfer) Display 

func (e *TagSvgFeComponentTransfer) Display(value interface{}) (ref *TagSvgFeComponentTransfer)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgFeComponentTransfer) DominantBaseline 

func (e *TagSvgFeComponentTransfer) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgFeComponentTransfer)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgFeComponentTransfer) Fill 

func (e *TagSvgFeComponentTransfer) Fill(value interface{}) (ref *TagSvgFeComponentTransfer)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgFeComponentTransfer) FillOpacity 

func (e *TagSvgFeComponentTransfer) FillOpacity(value interface{}) (ref *TagSvgFeComponentTransfer)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgFeComponentTransfer) FillRule 

func (e *TagSvgFeComponentTransfer) FillRule(fillRule SvgFillRule) (ref *TagSvgFeComponentTransfer)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgFeComponentTransfer) Filter 

func (e *TagSvgFeComponentTransfer) Filter(filter string) (ref *TagSvgFeComponentTransfer)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgFeComponentTransfer) FloodColor 

func (e *TagSvgFeComponentTransfer) FloodColor(floodColor interface{}) (ref *TagSvgFeComponentTransfer)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgFeComponentTransfer) FloodOpacity 

func (e *TagSvgFeComponentTransfer) FloodOpacity(floodOpacity float64) (ref *TagSvgFeComponentTransfer)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgFeComponentTransfer) FontFamily 

func (e *TagSvgFeComponentTransfer) FontFamily(fontFamily string) (ref *TagSvgFeComponentTransfer)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgFeComponentTransfer) FontSize 

func (e *TagSvgFeComponentTransfer) FontSize(fontSize interface{}) (ref *TagSvgFeComponentTransfer)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgFeComponentTransfer) FontSizeAdjust 

func (e *TagSvgFeComponentTransfer) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgFeComponentTransfer)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgFeComponentTransfer) FontStretch 

func (e *TagSvgFeComponentTransfer) FontStretch(fontStretch interface{}) (ref *TagSvgFeComponentTransfer)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgFeComponentTransfer) FontStyle 

func (e *TagSvgFeComponentTransfer) FontStyle(fontStyle FontStyleRule) (ref *TagSvgFeComponentTransfer)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgFeComponentTransfer) FontVariant 

func (e *TagSvgFeComponentTransfer) FontVariant(value interface{}) (ref *TagSvgFeComponentTransfer)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgFeComponentTransfer) FontWeight 

func (e *TagSvgFeComponentTransfer) FontWeight(value interface{}) (ref *TagSvgFeComponentTransfer)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgFeComponentTransfer) Get 

func (e *TagSvgFeComponentTransfer) Get() (el js.Value)

func (*TagSvgFeComponentTransfer) Height 

func (e *TagSvgFeComponentTransfer) Height(height interface{}) (ref *TagSvgFeComponentTransfer)

Height

English: 

The height attribute defines the vertical length of an element in the user coordinate system.
     float32: 1.0 = "100%"
     any other type: interface{}

Português: 

O atributo height define o comprimento vertical de um elemento no sistema de coordenadas do usuário.
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

func (*TagSvgFeComponentTransfer) Html 

func (e *TagSvgFeComponentTransfer) Html(value string) (ref *TagSvgFeComponentTransfer)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgFeComponentTransfer) Id 

func (e *TagSvgFeComponentTransfer) Id(id string) (ref *TagSvgFeComponentTransfer)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgFeComponentTransfer) ImageRendering 

func (e *TagSvgFeComponentTransfer) ImageRendering(imageRendering string) (ref *TagSvgFeComponentTransfer)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgFeComponentTransfer) In 

func (e *TagSvgFeComponentTransfer) In(in interface{}) (ref *TagSvgFeComponentTransfer)

In

English: 

The in attribute identifies input for the given filter primitive.

 Input:
   in: identifies input for the given filter primitive.
     KSvgIn... (e.g. KSvgInSourceAlpha)
     any other type: interface{}

The value can be either one of the six keywords defined below, or a string which matches a previous result attribute value within the same <filter> element. If no value is provided and this is the first filter primitive, then this filter primitive will use SourceGraphic as its input. If no value is provided and this is a subsequent filter primitive, then this filter primitive will use the result from the previous filter primitive as its input.

If the value for result appears multiple times within a given <filter> element, then a reference to that result will use the closest preceding filter primitive with the given value for attribute result.

Portuguese 

O atributo in identifica à entrada para a primitiva de filtro fornecida.

 Entrada:
   in: identifica à entrada para a primitiva de filtro fornecida.
     KSvgIn... (e.g. KSvgInSourceAlpha)
     qualquer outro tipo: interface{}

O valor pode ser uma das seis palavras-chave definidas abaixo ou uma string que corresponda a um valor de atributo de resultado anterior dentro do mesmo elemento <filter>. Se nenhum valor for fornecido e esta for a primeira primitiva de filtro, essa primitiva de filtro usará SourceGraphic como sua entrada. Se nenhum valor for fornecido e esta for uma primitiva de filtro subsequente, essa primitiva de filtro usará o resultado da primitiva de filtro anterior como sua entrada.

Se o valor do resultado aparecer várias vezes em um determinado elemento <filter>, uma referência à esse resultado usará a primitiva de filtro anterior mais próxima com o valor fornecido para o resultado do atributo.

func (*TagSvgFeComponentTransfer) Init 

func (e *TagSvgFeComponentTransfer) Init() (ref *TagSvgFeComponentTransfer)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgFeComponentTransfer) Lang 

func (e *TagSvgFeComponentTransfer) Lang(value interface{}) (ref *TagSvgFeComponentTransfer)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgFeComponentTransfer) LetterSpacing 

func (e *TagSvgFeComponentTransfer) LetterSpacing(value float64) (ref *TagSvgFeComponentTransfer)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgFeComponentTransfer) LightingColor 

func (e *TagSvgFeComponentTransfer) LightingColor(value interface{}) (ref *TagSvgFeComponentTransfer)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgFeComponentTransfer) MarkerEnd 

func (e *TagSvgFeComponentTransfer) MarkerEnd(value interface{}) (ref *TagSvgFeComponentTransfer)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgFeComponentTransfer) MarkerMid 

func (e *TagSvgFeComponentTransfer) MarkerMid(value interface{}) (ref *TagSvgFeComponentTransfer)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgFeComponentTransfer) MarkerStart 

func (e *TagSvgFeComponentTransfer) MarkerStart(value interface{}) (ref *TagSvgFeComponentTransfer)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgFeComponentTransfer) Mask 

func (e *TagSvgFeComponentTransfer) Mask(value interface{}) (ref *TagSvgFeComponentTransfer)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgFeComponentTransfer) Opacity 

func (e *TagSvgFeComponentTransfer) Opacity(value interface{}) (ref *TagSvgFeComponentTransfer)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgFeComponentTransfer) Overflow 

func (e *TagSvgFeComponentTransfer) Overflow(value interface{}) (ref *TagSvgFeComponentTransfer)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgFeComponentTransfer) PointerEvents 

func (e *TagSvgFeComponentTransfer) PointerEvents(value interface{}) (ref *TagSvgFeComponentTransfer)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgFeComponentTransfer) Result 

func (e *TagSvgFeComponentTransfer) Result(value interface{}) (ref *TagSvgFeComponentTransfer)

Result

English:

The result attribute defines the assigned name for this filter primitive. If supplied, then graphics that result from processing this filter primitive can be referenced by an in attribute on a subsequent filter primitive within the same <filter> element. If no value is provided, the output will only be available for re-use as the implicit input into the next filter primitive if that filter primitive provides no value for its in attribute.

Português:

O atributo result define o nome atribuído para esta primitiva de filtro. Se fornecido, os gráficos resultantes do processamento dessa primitiva de filtro podem ser referenciados por um atributo in em uma primitiva de filtro subsequente dentro do mesmo elemento <filter>. Se nenhum valor for fornecido, a saída só estará disponível para reutilização como entrada implícita na próxima primitiva de filtro se essa primitiva de filtro não fornecer valor para seu atributo in.

func (*TagSvgFeComponentTransfer) ShapeRendering 

func (e *TagSvgFeComponentTransfer) ShapeRendering(value interface{}) (ref *TagSvgFeComponentTransfer)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgFeComponentTransfer) StopColor 

func (e *TagSvgFeComponentTransfer) StopColor(value interface{}) (ref *TagSvgFeComponentTransfer)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgFeComponentTransfer) StopOpacity 

func (e *TagSvgFeComponentTransfer) StopOpacity(value interface{}) (ref *TagSvgFeComponentTransfer)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgFeComponentTransfer) Stroke 

func (e *TagSvgFeComponentTransfer) Stroke(value interface{}) (ref *TagSvgFeComponentTransfer)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgFeComponentTransfer) StrokeDasharray 

func (e *TagSvgFeComponentTransfer) StrokeDasharray(value interface{}) (ref *TagSvgFeComponentTransfer)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgFeComponentTransfer) StrokeLineCap 

func (e *TagSvgFeComponentTransfer) StrokeLineCap(value interface{}) (ref *TagSvgFeComponentTransfer)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgFeComponentTransfer) StrokeLineJoin 

func (e *TagSvgFeComponentTransfer) StrokeLineJoin(value interface{}) (ref *TagSvgFeComponentTransfer)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgFeComponentTransfer) StrokeMiterLimit 

func (e *TagSvgFeComponentTransfer) StrokeMiterLimit(value float64) (ref *TagSvgFeComponentTransfer)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgFeComponentTransfer) StrokeOpacity 

func (e *TagSvgFeComponentTransfer) StrokeOpacity(value interface{}) (ref *TagSvgFeComponentTransfer)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgFeComponentTransfer) StrokeWidth 

func (e *TagSvgFeComponentTransfer) StrokeWidth(value interface{}) (ref *TagSvgFeComponentTransfer)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeComponentTransfer) Style 

func (e *TagSvgFeComponentTransfer) Style(value string) (ref *TagSvgFeComponentTransfer)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgFeComponentTransfer) Tabindex 

func (e *TagSvgFeComponentTransfer) Tabindex(value int) (ref *TagSvgFeComponentTransfer)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgFeComponentTransfer) Text 

func (e *TagSvgFeComponentTransfer) Text(value string) (ref *TagSvgFeComponentTransfer)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgFeComponentTransfer) TextAnchor 

func (e *TagSvgFeComponentTransfer) TextAnchor(value interface{}) (ref *TagSvgFeComponentTransfer)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgFeComponentTransfer) TextDecoration 

func (e *TagSvgFeComponentTransfer) TextDecoration(value interface{}) (ref *TagSvgFeComponentTransfer)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgFeComponentTransfer) TextRendering 

func (e *TagSvgFeComponentTransfer) TextRendering(value interface{}) (ref *TagSvgFeComponentTransfer)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgFeComponentTransfer) Transform 

func (e *TagSvgFeComponentTransfer) Transform(value interface{}) (ref *TagSvgFeComponentTransfer)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgFeComponentTransfer) UnicodeBidi 

func (e *TagSvgFeComponentTransfer) UnicodeBidi(value interface{}) (ref *TagSvgFeComponentTransfer)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgFeComponentTransfer) VectorEffect 

func (e *TagSvgFeComponentTransfer) VectorEffect(value interface{}) (ref *TagSvgFeComponentTransfer)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgFeComponentTransfer) Visibility 

func (e *TagSvgFeComponentTransfer) Visibility(value interface{}) (ref *TagSvgFeComponentTransfer)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgFeComponentTransfer) Width 

func (e *TagSvgFeComponentTransfer) Width(value interface{}) (ref *TagSvgFeComponentTransfer)

Width

English:

The width attribute defines the horizontal length of an element in the user coordinate system. 

Input:
  value: the horizontal length of an element
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo largura define o comprimento horizontal de um elemento no sistema de coordenadas do usuário. 

Entrada:
  value: o comprimento horizontal de um elemento
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeComponentTransfer) WordSpacing 

func (e *TagSvgFeComponentTransfer) WordSpacing(value interface{}) (ref *TagSvgFeComponentTransfer)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgFeComponentTransfer) WritingMode 

func (e *TagSvgFeComponentTransfer) WritingMode(value interface{}) (ref *TagSvgFeComponentTransfer)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgFeComponentTransfer) X 

func (e *TagSvgFeComponentTransfer) X(value interface{}) (ref *TagSvgFeComponentTransfer)

X

English:

The x attribute defines an x-axis coordinate in the user coordinate system. 

Input:
  value: defines an x-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo x define uma coordenada do eixo x no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo x
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgFeComponentTransfer) XmlLang 

func (e *TagSvgFeComponentTransfer) XmlLang(value interface{}) (ref *TagSvgFeComponentTransfer)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

func (*TagSvgFeComponentTransfer) Y 

func (e *TagSvgFeComponentTransfer) Y(value interface{}) (ref *TagSvgFeComponentTransfer)

Y

English:

The y attribute defines an y-axis coordinate in the user coordinate system. 

Input:
  value: defines an y-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo y define uma coordenada do eixo y no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo y
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

type TagSvgFeComposite 

type TagSvgFeComposite struct {
	// contains filtered or unexported fields
}

TagSvgFeComposite

English:

The <feComposite> SVG filter primitive performs the combination of two input images pixel-wise in image space using one of the Porter-Duff compositing operations: over, in, atop, out, xor, lighter, or arithmetic.

The table below shows each of these operations using an image of the MDN logo composited with a red circle:

Português:

A primitiva de filtro SVG <feComposite> executa a combinação de duas imagens de entrada pixel a pixel no espaço da imagem usando uma das operações de composição de Porter-Duff: sobre, dentro, em cima, fora, xor, mais leve ou aritmética.

A tabela abaixo mostra cada uma dessas operações usando uma imagem do logotipo do MDN composta por um círculo vermelho:

func (*TagSvgFeComposite) Append 

func (e *TagSvgFeComposite) Append(elements ...Compatible) (ref *TagSvgFeComposite)

func (*TagSvgFeComposite) AppendById 

func (e *TagSvgFeComposite) AppendById(appendId string) (ref *TagSvgFeComposite)

func (*TagSvgFeComposite) AppendToElement 

func (e *TagSvgFeComposite) AppendToElement(el js.Value) (ref *TagSvgFeComposite)

func (*TagSvgFeComposite) AppendToStage 

func (e *TagSvgFeComposite) AppendToStage() (ref *TagSvgFeComposite)

func (*TagSvgFeComposite) BaselineShift 

func (e *TagSvgFeComposite) BaselineShift(baselineShift interface{}) (ref *TagSvgFeComposite)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgFeComposite) Class 

func (e *TagSvgFeComposite) Class(class string) (ref *TagSvgFeComposite)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgFeComposite) ClipPath 

func (e *TagSvgFeComposite) ClipPath(clipPath string) (ref *TagSvgFeComposite)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgFeComposite) ClipRule 

func (e *TagSvgFeComposite) ClipRule(value interface{}) (ref *TagSvgFeComposite)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgFeComposite) Color 

func (e *TagSvgFeComposite) Color(value interface{}) (ref *TagSvgFeComposite)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgFeComposite) ColorInterpolation 

func (e *TagSvgFeComposite) ColorInterpolation(value interface{}) (ref *TagSvgFeComposite)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgFeComposite) ColorInterpolationFilters 

func (e *TagSvgFeComposite) ColorInterpolationFilters(value interface{}) (ref *TagSvgFeComposite)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgFeComposite) CreateElement 

func (e *TagSvgFeComposite) CreateElement() (ref *TagSvgFeComposite)

func (*TagSvgFeComposite) Cursor 

func (e *TagSvgFeComposite) Cursor(cursor SvgCursor) (ref *TagSvgFeComposite)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgFeComposite) Direction 

func (e *TagSvgFeComposite) Direction(direction SvgDirection) (ref *TagSvgFeComposite)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgFeComposite) Display 

func (e *TagSvgFeComposite) Display(value interface{}) (ref *TagSvgFeComposite)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgFeComposite) DominantBaseline 

func (e *TagSvgFeComposite) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgFeComposite)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgFeComposite) Fill 

func (e *TagSvgFeComposite) Fill(value interface{}) (ref *TagSvgFeComposite)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgFeComposite) FillOpacity 

func (e *TagSvgFeComposite) FillOpacity(value interface{}) (ref *TagSvgFeComposite)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgFeComposite) FillRule 

func (e *TagSvgFeComposite) FillRule(fillRule SvgFillRule) (ref *TagSvgFeComposite)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgFeComposite) Filter 

func (e *TagSvgFeComposite) Filter(filter string) (ref *TagSvgFeComposite)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgFeComposite) FloodColor 

func (e *TagSvgFeComposite) FloodColor(floodColor interface{}) (ref *TagSvgFeComposite)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgFeComposite) FloodOpacity 

func (e *TagSvgFeComposite) FloodOpacity(floodOpacity float64) (ref *TagSvgFeComposite)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgFeComposite) FontFamily 

func (e *TagSvgFeComposite) FontFamily(fontFamily string) (ref *TagSvgFeComposite)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgFeComposite) FontSize 

func (e *TagSvgFeComposite) FontSize(fontSize interface{}) (ref *TagSvgFeComposite)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgFeComposite) FontSizeAdjust 

func (e *TagSvgFeComposite) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgFeComposite)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgFeComposite) FontStretch 

func (e *TagSvgFeComposite) FontStretch(fontStretch interface{}) (ref *TagSvgFeComposite)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgFeComposite) FontStyle 

func (e *TagSvgFeComposite) FontStyle(fontStyle FontStyleRule) (ref *TagSvgFeComposite)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgFeComposite) FontVariant 

func (e *TagSvgFeComposite) FontVariant(value interface{}) (ref *TagSvgFeComposite)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgFeComposite) FontWeight 

func (e *TagSvgFeComposite) FontWeight(value interface{}) (ref *TagSvgFeComposite)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgFeComposite) Get 

func (e *TagSvgFeComposite) Get() (el js.Value)

func (*TagSvgFeComposite) Height 

func (e *TagSvgFeComposite) Height(height interface{}) (ref *TagSvgFeComposite)

Height

English: 

The height attribute defines the vertical length of an element in the user coordinate system.
     float32: 1.0 = "100%"
     any other type: interface{}

Português: 

O atributo height define o comprimento vertical de um elemento no sistema de coordenadas do usuário.
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

func (*TagSvgFeComposite) Html 

func (e *TagSvgFeComposite) Html(value string) (ref *TagSvgFeComposite)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgFeComposite) Id 

func (e *TagSvgFeComposite) Id(id string) (ref *TagSvgFeComposite)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgFeComposite) ImageRendering 

func (e *TagSvgFeComposite) ImageRendering(imageRendering string) (ref *TagSvgFeComposite)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgFeComposite) In 

func (e *TagSvgFeComposite) In(in interface{}) (ref *TagSvgFeComposite)

In

English: 

The in attribute identifies input for the given filter primitive.

 Input:
   in: identifies input for the given filter primitive.
     KSvgIn... (e.g. KSvgInSourceAlpha)
     any other type: interface{}

The value can be either one of the six keywords defined below, or a string which matches a previous result attribute value within the same <filter> element. If no value is provided and this is the first filter primitive, then this filter primitive will use SourceGraphic as its input. If no value is provided and this is a subsequent filter primitive, then this filter primitive will use the result from the previous filter primitive as its input.

If the value for result appears multiple times within a given <filter> element, then a reference to that result will use the closest preceding filter primitive with the given value for attribute result.

Portuguese 

O atributo in identifica à entrada para a primitiva de filtro fornecida.

 Entrada:
   in: identifica à entrada para a primitiva de filtro fornecida.
     KSvgIn... (e.g. KSvgInSourceAlpha)
     qualquer outro tipo: interface{}

O valor pode ser uma das seis palavras-chave definidas abaixo ou uma string que corresponda a um valor de atributo de resultado anterior dentro do mesmo elemento <filter>. Se nenhum valor for fornecido e esta for a primeira primitiva de filtro, essa primitiva de filtro usará SourceGraphic como sua entrada. Se nenhum valor for fornecido e esta for uma primitiva de filtro subsequente, essa primitiva de filtro usará o resultado da primitiva de filtro anterior como sua entrada.

Se o valor do resultado aparecer várias vezes em um determinado elemento <filter>, uma referência à esse resultado usará a primitiva de filtro anterior mais próxima com o valor fornecido para o resultado do atributo.

func (*TagSvgFeComposite) In2 

func (e *TagSvgFeComposite) In2(in2 interface{}) (ref *TagSvgFeComposite)

In2

English: 

The in2 attribute identifies the second input for the given filter primitive. It works exactly like the in
attribute.

 Input:
   in2: identifies the second input for the given filter primitive.
     KSvgIn2... (e.g. KSvgIn2SourceAlpha)
     string: url(#myClip)
     any other type: interface{}

Portuguese 

O atributo in2 identifica a segunda entrada para a primitiva de filtro fornecida. Funciona exatamente como o
atributo in.

 Entrada:
   in2: identifica a segunda entrada para a primitiva de filtro fornecida.
     KSvgIn2... (ex. KSvgIn2SourceAlpha)
     string: url(#myClip)
     qualquer outro tipo: interface{}

func (*TagSvgFeComposite) Init 

func (e *TagSvgFeComposite) Init() (ref *TagSvgFeComposite)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgFeComposite) K1 

func (e *TagSvgFeComposite) K1(k1 float64) (ref *TagSvgFeComposite)

K1

English: 

The k1 attribute defines one of the values to be used within the arithmetic operation of the <feComposite>
filter primitive.

The pixel composition is computed using the following formula: 

result = k1*i1*i2 + k2*i1 + k3*i2 + k4

Portuguese 

O atributo k1 define um dos valores a serem usados na operação aritmética da primitiva de filtro <feComposite>.

A composição de pixels é calculada usando a seguinte fórmula: 

result = k1*i1*i2 + k2*i1 + k3*i2 + k4

func (*TagSvgFeComposite) K2 

func (e *TagSvgFeComposite) K2(k2 float64) (ref *TagSvgFeComposite)

K2

English: 

The k2 attribute defines one of the values to be used within the arithmetic operation of the <feComposite> filter
primitive.

The pixel composition is computed using the following formula: 

result = k1*i1*i2 + k2*i1 + k3*i2 + k4

Portuguese 

O atributo k2 define um dos valores a serem usados na operação aritmética da primitiva de filtro <feComposite>.

A composição de pixels é calculada usando a seguinte fórmula: 

result = k1*i1*i2 + k2*i1 + k3*i2 + k4

func (*TagSvgFeComposite) K3 

func (e *TagSvgFeComposite) K3(k3 float64) (ref *TagSvgFeComposite)

K3

English: 

The k3 attribute defines one of the values to be used within the arithmetic operation of the <feComposite>
filter primitive.

The pixel composition is computed using the following formula: 

result = k1*i1*i2 + k2*i1 + k3*i2 + k4

Portuguese 

O atributo k3 define um dos valores a serem usados na operação aritmética da primitiva de filtro <feComposite>.

A composição de pixels é calculada usando a seguinte fórmula: 

result = k1*i1*i2 + k2*i1 + k3*i2 + k4

func (*TagSvgFeComposite) K4 

func (e *TagSvgFeComposite) K4(k4 float64) (ref *TagSvgFeComposite)

K4

English: 

The k4 attribute defines one of the values to be used within the arithmetic operation of the <feComposite>
filter primitive.

The pixel composition is computed using the following formula: 

result = k1*i1*i2 + k2*i1 + k3*i2 + k4

Portuguese 

O atributo k4 define um dos valores a serem usados na operação aritmética da primitiva de filtro <feComposite>.

A composição de pixels é calculada usando a seguinte fórmula: 

result = k1*i1*i2 + k2*i1 + k3*i2 + k4

func (*TagSvgFeComposite) Lang 

func (e *TagSvgFeComposite) Lang(value interface{}) (ref *TagSvgFeComposite)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgFeComposite) LetterSpacing 

func (e *TagSvgFeComposite) LetterSpacing(value float64) (ref *TagSvgFeComposite)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgFeComposite) LightingColor 

func (e *TagSvgFeComposite) LightingColor(value interface{}) (ref *TagSvgFeComposite)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgFeComposite) MarkerEnd 

func (e *TagSvgFeComposite) MarkerEnd(value interface{}) (ref *TagSvgFeComposite)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgFeComposite) MarkerMid 

func (e *TagSvgFeComposite) MarkerMid(value interface{}) (ref *TagSvgFeComposite)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgFeComposite) MarkerStart 

func (e *TagSvgFeComposite) MarkerStart(value interface{}) (ref *TagSvgFeComposite)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgFeComposite) Mask 

func (e *TagSvgFeComposite) Mask(value interface{}) (ref *TagSvgFeComposite)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgFeComposite) Opacity 

func (e *TagSvgFeComposite) Opacity(value interface{}) (ref *TagSvgFeComposite)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgFeComposite) Operator 

func (e *TagSvgFeComposite) Operator(value interface{}) (ref *TagSvgFeComposite)

Operator

English:

The operator attribute has two meanings based on the context it's used in. Either it defines the compositing or morphing operation to be performed. 

Input:
  value: defines the compositing or morphing
    const: KSvgOperatorFeComposite... (e.g. KSvgOperatorFeCompositeOver)
    any other type: interface{}

Português:

O atributo operador tem dois significados com base no contexto em que é usado. Ele define a operação de composição ou transformação a ser executada. 

Entrada:
  value: define a composição ou morphing
    const: KSvgOperatorFeComposite... (e.g. KSvgOperatorFeCompositeOver)
    qualquer outro tipo: interface{}

func (*TagSvgFeComposite) Overflow 

func (e *TagSvgFeComposite) Overflow(value interface{}) (ref *TagSvgFeComposite)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgFeComposite) PointerEvents 

func (e *TagSvgFeComposite) PointerEvents(value interface{}) (ref *TagSvgFeComposite)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgFeComposite) Result 

func (e *TagSvgFeComposite) Result(value interface{}) (ref *TagSvgFeComposite)

Result

English:

The result attribute defines the assigned name for this filter primitive. If supplied, then graphics that result from processing this filter primitive can be referenced by an in attribute on a subsequent filter primitive within the same <filter> element. If no value is provided, the output will only be available for re-use as the implicit input into the next filter primitive if that filter primitive provides no value for its in attribute.

Português:

O atributo result define o nome atribuído para esta primitiva de filtro. Se fornecido, os gráficos resultantes do processamento dessa primitiva de filtro podem ser referenciados por um atributo in em uma primitiva de filtro subsequente dentro do mesmo elemento <filter>. Se nenhum valor for fornecido, a saída só estará disponível para reutilização como entrada implícita na próxima primitiva de filtro se essa primitiva de filtro não fornecer valor para seu atributo in.

func (*TagSvgFeComposite) ShapeRendering 

func (e *TagSvgFeComposite) ShapeRendering(value interface{}) (ref *TagSvgFeComposite)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgFeComposite) StopColor 

func (e *TagSvgFeComposite) StopColor(value interface{}) (ref *TagSvgFeComposite)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgFeComposite) StopOpacity 

func (e *TagSvgFeComposite) StopOpacity(value interface{}) (ref *TagSvgFeComposite)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgFeComposite) Stroke 

func (e *TagSvgFeComposite) Stroke(value interface{}) (ref *TagSvgFeComposite)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgFeComposite) StrokeDasharray 

func (e *TagSvgFeComposite) StrokeDasharray(value interface{}) (ref *TagSvgFeComposite)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgFeComposite) StrokeLineCap 

func (e *TagSvgFeComposite) StrokeLineCap(value interface{}) (ref *TagSvgFeComposite)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgFeComposite) StrokeLineJoin 

func (e *TagSvgFeComposite) StrokeLineJoin(value interface{}) (ref *TagSvgFeComposite)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgFeComposite) StrokeMiterLimit 

func (e *TagSvgFeComposite) StrokeMiterLimit(value float64) (ref *TagSvgFeComposite)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgFeComposite) StrokeOpacity 

func (e *TagSvgFeComposite) StrokeOpacity(value interface{}) (ref *TagSvgFeComposite)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgFeComposite) StrokeWidth 

func (e *TagSvgFeComposite) StrokeWidth(value interface{}) (ref *TagSvgFeComposite)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeComposite) Style 

func (e *TagSvgFeComposite) Style(value string) (ref *TagSvgFeComposite)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgFeComposite) Tabindex 

func (e *TagSvgFeComposite) Tabindex(value int) (ref *TagSvgFeComposite)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgFeComposite) Text 

func (e *TagSvgFeComposite) Text(value string) (ref *TagSvgFeComposite)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgFeComposite) TextAnchor 

func (e *TagSvgFeComposite) TextAnchor(value interface{}) (ref *TagSvgFeComposite)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgFeComposite) TextDecoration 

func (e *TagSvgFeComposite) TextDecoration(value interface{}) (ref *TagSvgFeComposite)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgFeComposite) TextRendering 

func (e *TagSvgFeComposite) TextRendering(value interface{}) (ref *TagSvgFeComposite)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgFeComposite) Transform 

func (e *TagSvgFeComposite) Transform(value interface{}) (ref *TagSvgFeComposite)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgFeComposite) UnicodeBidi 

func (e *TagSvgFeComposite) UnicodeBidi(value interface{}) (ref *TagSvgFeComposite)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgFeComposite) VectorEffect 

func (e *TagSvgFeComposite) VectorEffect(value interface{}) (ref *TagSvgFeComposite)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgFeComposite) Visibility 

func (e *TagSvgFeComposite) Visibility(value interface{}) (ref *TagSvgFeComposite)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgFeComposite) Width 

func (e *TagSvgFeComposite) Width(value interface{}) (ref *TagSvgFeComposite)

Width

English:

The width attribute defines the horizontal length of an element in the user coordinate system. 

Input:
  value: the horizontal length of an element
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo largura define o comprimento horizontal de um elemento no sistema de coordenadas do usuário. 

Entrada:
  value: o comprimento horizontal de um elemento
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeComposite) WordSpacing 

func (e *TagSvgFeComposite) WordSpacing(value interface{}) (ref *TagSvgFeComposite)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgFeComposite) WritingMode 

func (e *TagSvgFeComposite) WritingMode(value interface{}) (ref *TagSvgFeComposite)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgFeComposite) X 

func (e *TagSvgFeComposite) X(value interface{}) (ref *TagSvgFeComposite)

X

English:

The x attribute defines an x-axis coordinate in the user coordinate system. 

Input:
  value: defines an x-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo x define uma coordenada do eixo x no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo x
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgFeComposite) XmlLang 

func (e *TagSvgFeComposite) XmlLang(value interface{}) (ref *TagSvgFeComposite)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

func (*TagSvgFeComposite) Y 

func (e *TagSvgFeComposite) Y(value interface{}) (ref *TagSvgFeComposite)

Y

English:

The y attribute defines an y-axis coordinate in the user coordinate system. 

Input:
  value: defines an y-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo y define uma coordenada do eixo y no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo y
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

type TagSvgFeConvolveMatrix 

type TagSvgFeConvolveMatrix struct {
	// contains filtered or unexported fields
}

TagSvgFeConvolveMatrix

English:

The <feConvolveMatrix> SVG filter primitive applies a matrix convolution filter effect. A convolution combines pixels in the input image with neighboring pixels to produce a resulting image. A wide variety of imaging operations can be achieved through convolutions, including blurring, edge detection, sharpening, embossing and beveling.

A matrix convolution is based on an n-by-m matrix (the convolution kernel) which describes how a given pixel value in the input image is combined with its neighboring pixel values to produce a resulting pixel value. Each result pixel is determined by applying the kernel matrix to the corresponding source pixel and its neighboring pixels.

The basic convolution formula which is applied to each color value for a given pixel is: 

COLORX,Y = ( SUM I=0 to [orderY-1] { SUM J=0 to [orderX-1] { SOURCE X-targetX+J, Y-targetY+I *
             kernelMatrixorderX-J-1, orderY-I-1 } } ) / divisor + bias * ALPHAX,Y

where "orderX" and "orderY" represent the X and Y values for the 'order' attribute, "targetX" represents the value of the 'targetX' attribute, "targetY" represents the value of the 'targetY' attribute, "kernelMatrix" represents the value of the 'kernelMatrix' attribute, "divisor" represents the value of the 'divisor' attribute, and "bias" represents the value of the 'bias' attribute.

Note in the above formulas that the values in the kernel matrix are applied such that the kernel matrix is rotated 180 degrees relative to the source and destination images in order to match convolution theory as described in many computer graphics textbooks.

To illustrate, suppose you have a input image which is 5 pixels by 5 pixels, whose color values for one of the color channels are as follows: 

0    20  40 235 235
100 120 140 235 235
200 220 240 235 235
225 225 255 255 255
225 225 255 255 255

and you define a 3-by-3 convolution kernel as follows: 

1 2 3
4 5 6
7 8 9

Let's focus on the color value at the second row and second column of the image (source pixel value is 120). Assuming the simplest case (where the input image's pixel grid aligns perfectly with the kernel's pixel grid) and assuming default values for attributes 'divisor', 'targetX' and 'targetY', then resulting color value will be: 

(9*  0 + 8* 20 + 7* 40 +
 6*100 + 5*120 + 4*140 +
 3*200 + 2*220 + 1*240) /
(9+8+7+6+5+4+3+2+1)

Português:

A primitiva de filtro SVG <feConvolveMatrix> aplica um efeito de filtro de convolução de matriz. Uma convolução combina pixels na imagem de entrada com pixels vizinhos para produzir uma imagem resultante. Uma ampla variedade de operações de imagem pode ser alcançada por meio de convoluções, incluindo desfoque, detecção de bordas, nitidez, relevo e chanfro.

Uma convolução de matriz é baseada em uma matriz n por m (o kernel de convolução) que descreve como um determinado valor de pixel na imagem de entrada é combinado com seus valores de pixel vizinhos para produzir um valor de pixel resultante. Cada pixel resultante é determinado pela aplicação da matriz kernel ao pixel de origem correspondente e seus pixels vizinhos. A fórmula de convolução básica que é aplicada a cada valor de cor para um determinado pixel é: 

COLORX,Y = ( SUM I=0 to [orderY-1] { SUM J=0 to [orderX-1] { SOURCE X-targetX+J, Y-targetY+I *
             kernelMatrixorderX-J-1, orderY-I-1 } } ) / divisor + bias * ALPHAX,Y

onde "orderX" e "orderY" representam os valores X e Y para o atributo 'order', "targetX" representa o valor do atributo 'targetX', "targetY" representa o valor do atributo 'targetY', "kernelMatrix" representa o valor do atributo 'kernelMatrix', "divisor" representa o valor do atributo 'divisor' e "bias" representa o valor do atributo 'bias'.

Observe nas fórmulas acima que os valores na matriz do kernel são aplicados de tal forma que a matriz do kernel é girada 180 graus em relação às imagens de origem e destino para corresponder à teoria de convolução conforme descrito em muitos livros de computação gráfica.

Para ilustrar, suponha que você tenha uma imagem de entrada com 5 pixels por 5 pixels, cujos valores de cor para um dos canais de cores sejam os seguintes: 

0    20  40 235 235
100 120 140 235 235
200 220 240 235 235
225 225 255 255 255
225 225 255 255 255

e você define um kernel de convolução 3 por 3 da seguinte forma: 

1 2 3
4 5 6
7 8 9

Vamos nos concentrar no valor da cor na segunda linha e na segunda coluna da imagem (o valor do pixel de origem é 120). Assumindo o caso mais simples (onde a grade de pixels da imagem de entrada se alinha perfeitamente com a grade de pixels do kernel) e assumindo valores padrão para os atributos 'divisor', 'targetX' e 'targetY', o valor da cor resultante será: 

(9*  0 + 8* 20 + 7* 40 +
 6*100 + 5*120 + 4*140 +
 3*200 + 2*220 + 1*240) /
(9+8+7+6+5+4+3+2+1)

func (*TagSvgFeConvolveMatrix) Append 

func (e *TagSvgFeConvolveMatrix) Append(elements ...Compatible) (ref *TagSvgFeConvolveMatrix)

func (*TagSvgFeConvolveMatrix) AppendById 

func (e *TagSvgFeConvolveMatrix) AppendById(appendId string) (ref *TagSvgFeConvolveMatrix)

func (*TagSvgFeConvolveMatrix) AppendToElement 

func (e *TagSvgFeConvolveMatrix) AppendToElement(el js.Value) (ref *TagSvgFeConvolveMatrix)

func (*TagSvgFeConvolveMatrix) AppendToStage 

func (e *TagSvgFeConvolveMatrix) AppendToStage() (ref *TagSvgFeConvolveMatrix)

func (*TagSvgFeConvolveMatrix) BaselineShift 

func (e *TagSvgFeConvolveMatrix) BaselineShift(baselineShift interface{}) (ref *TagSvgFeConvolveMatrix)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgFeConvolveMatrix) Bias 

func (e *TagSvgFeConvolveMatrix) Bias(bias float64) (ref *TagSvgFeConvolveMatrix)

Bias

English: 

The bias attribute shifts the range of the filter. After applying the kernelMatrix of the <feConvolveMatrix> element
to the input image to yield a number and applied the divisor attribute, the bias attribute is added to each
component. This allows representation of values that would otherwise be clamped to 0 or 1.

 Input:
   bias: shifts the range of the filter

Português: 

O atributo bias muda o intervalo do filtro. Depois de aplicar o kernelMatrix do elemento <feConvolveMatrix> à imagem
de entrada para gerar um número e aplicar o atributo divisor, o atributo bias é adicionado a cada componente. Isso
permite a representação de valores que de outra forma seriam fixados em 0 ou 1.

 Entrada:
   bias: muda o intervalo do filtro

func (*TagSvgFeConvolveMatrix) Class 

func (e *TagSvgFeConvolveMatrix) Class(class string) (ref *TagSvgFeConvolveMatrix)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgFeConvolveMatrix) ClipPath 

func (e *TagSvgFeConvolveMatrix) ClipPath(clipPath string) (ref *TagSvgFeConvolveMatrix)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgFeConvolveMatrix) ClipRule 

func (e *TagSvgFeConvolveMatrix) ClipRule(value interface{}) (ref *TagSvgFeConvolveMatrix)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgFeConvolveMatrix) Color 

func (e *TagSvgFeConvolveMatrix) Color(value interface{}) (ref *TagSvgFeConvolveMatrix)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgFeConvolveMatrix) ColorInterpolation 

func (e *TagSvgFeConvolveMatrix) ColorInterpolation(value interface{}) (ref *TagSvgFeConvolveMatrix)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgFeConvolveMatrix) ColorInterpolationFilters 

func (e *TagSvgFeConvolveMatrix) ColorInterpolationFilters(value interface{}) (ref *TagSvgFeConvolveMatrix)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgFeConvolveMatrix) CreateElement 

func (e *TagSvgFeConvolveMatrix) CreateElement() (ref *TagSvgFeConvolveMatrix)

func (*TagSvgFeConvolveMatrix) Cursor 

func (e *TagSvgFeConvolveMatrix) Cursor(cursor SvgCursor) (ref *TagSvgFeConvolveMatrix)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgFeConvolveMatrix) Direction 

func (e *TagSvgFeConvolveMatrix) Direction(direction SvgDirection) (ref *TagSvgFeConvolveMatrix)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgFeConvolveMatrix) Display 

func (e *TagSvgFeConvolveMatrix) Display(value interface{}) (ref *TagSvgFeConvolveMatrix)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgFeConvolveMatrix) Divisor 

func (e *TagSvgFeConvolveMatrix) Divisor(divisor float64) (ref *TagSvgFeConvolveMatrix)

Divisor

English: 

The divisor attribute specifies the value by which the resulting number of applying the kernelMatrix of a
<feConvolveMatrix> element to the input image color value is divided to yield the destination color value.

 Input:
   divisor: specifies the divisor value to apply to the original color

A divisor that is the sum of all the matrix values tends to have an evening effect on the overall color intensity of the result.

Português: 

O atributo divisor especifica o valor pelo qual o número resultante da aplicação do kernelMatrix de um elemento
<feConvolveMatrix> ao valor da cor da imagem de entrada é dividido para gerar o valor da cor de destino.

 Entrada:
   divisor: especifica o valor do divisor a ser aplicado na cor original

A divisor that is the sum of all the matrix values tends to have an evening effect on the overall color intensity of the result.

func (*TagSvgFeConvolveMatrix) DominantBaseline 

func (e *TagSvgFeConvolveMatrix) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgFeConvolveMatrix)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgFeConvolveMatrix) EdgeMode 

func (e *TagSvgFeConvolveMatrix) EdgeMode(edgeMode SvgEdgeMode) (ref *TagSvgFeConvolveMatrix)

EdgeMode

English: 

The edgeMode attribute determines how to extend the input image as necessary with color values so that the matrix
operations can be applied when the kernel is positioned at or near the edge of the input image.

Portuguese 

O atributo edgeMode determina como estender a imagem de entrada conforme necessário com valores de cor para que as
operações de matriz possam ser aplicadas quando o kernel estiver posicionado na borda da imagem de entrada ou
próximo a ela.

func (*TagSvgFeConvolveMatrix) Fill 

func (e *TagSvgFeConvolveMatrix) Fill(value interface{}) (ref *TagSvgFeConvolveMatrix)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgFeConvolveMatrix) FillOpacity 

func (e *TagSvgFeConvolveMatrix) FillOpacity(value interface{}) (ref *TagSvgFeConvolveMatrix)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgFeConvolveMatrix) FillRule 

func (e *TagSvgFeConvolveMatrix) FillRule(fillRule SvgFillRule) (ref *TagSvgFeConvolveMatrix)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgFeConvolveMatrix) Filter 

func (e *TagSvgFeConvolveMatrix) Filter(filter string) (ref *TagSvgFeConvolveMatrix)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgFeConvolveMatrix) FloodColor 

func (e *TagSvgFeConvolveMatrix) FloodColor(floodColor interface{}) (ref *TagSvgFeConvolveMatrix)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgFeConvolveMatrix) FloodOpacity 

func (e *TagSvgFeConvolveMatrix) FloodOpacity(floodOpacity float64) (ref *TagSvgFeConvolveMatrix)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgFeConvolveMatrix) FontFamily 

func (e *TagSvgFeConvolveMatrix) FontFamily(fontFamily string) (ref *TagSvgFeConvolveMatrix)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgFeConvolveMatrix) FontSize 

func (e *TagSvgFeConvolveMatrix) FontSize(fontSize interface{}) (ref *TagSvgFeConvolveMatrix)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgFeConvolveMatrix) FontSizeAdjust 

func (e *TagSvgFeConvolveMatrix) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgFeConvolveMatrix)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgFeConvolveMatrix) FontStretch 

func (e *TagSvgFeConvolveMatrix) FontStretch(fontStretch interface{}) (ref *TagSvgFeConvolveMatrix)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgFeConvolveMatrix) FontStyle 

func (e *TagSvgFeConvolveMatrix) FontStyle(fontStyle FontStyleRule) (ref *TagSvgFeConvolveMatrix)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgFeConvolveMatrix) FontVariant 

func (e *TagSvgFeConvolveMatrix) FontVariant(value interface{}) (ref *TagSvgFeConvolveMatrix)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgFeConvolveMatrix) FontWeight 

func (e *TagSvgFeConvolveMatrix) FontWeight(value interface{}) (ref *TagSvgFeConvolveMatrix)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgFeConvolveMatrix) Get 

func (e *TagSvgFeConvolveMatrix) Get() (el js.Value)

func (*TagSvgFeConvolveMatrix) Height 

func (e *TagSvgFeConvolveMatrix) Height(height interface{}) (ref *TagSvgFeConvolveMatrix)

Height

English: 

The height attribute defines the vertical length of an element in the user coordinate system.
     float32: 1.0 = "100%"
     any other type: interface{}

Português: 

O atributo height define o comprimento vertical de um elemento no sistema de coordenadas do usuário.
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

func (*TagSvgFeConvolveMatrix) Html 

func (e *TagSvgFeConvolveMatrix) Html(value string) (ref *TagSvgFeConvolveMatrix)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgFeConvolveMatrix) Id 

func (e *TagSvgFeConvolveMatrix) Id(id string) (ref *TagSvgFeConvolveMatrix)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgFeConvolveMatrix) ImageRendering 

func (e *TagSvgFeConvolveMatrix) ImageRendering(imageRendering string) (ref *TagSvgFeConvolveMatrix)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgFeConvolveMatrix) In 

func (e *TagSvgFeConvolveMatrix) In(in interface{}) (ref *TagSvgFeConvolveMatrix)

In

English: 

The in attribute identifies input for the given filter primitive.

 Input:
   in: identifies input for the given filter primitive.
     KSvgIn... (e.g. KSvgInSourceAlpha)
     any other type: interface{}

The value can be either one of the six keywords defined below, or a string which matches a previous result attribute value within the same <filter> element. If no value is provided and this is the first filter primitive, then this filter primitive will use SourceGraphic as its input. If no value is provided and this is a subsequent filter primitive, then this filter primitive will use the result from the previous filter primitive as its input.

If the value for result appears multiple times within a given <filter> element, then a reference to that result will use the closest preceding filter primitive with the given value for attribute result.

Portuguese 

O atributo in identifica à entrada para a primitiva de filtro fornecida.

 Entrada:
   in: identifica à entrada para a primitiva de filtro fornecida.
     KSvgIn... (e.g. KSvgInSourceAlpha)
     qualquer outro tipo: interface{}

O valor pode ser uma das seis palavras-chave definidas abaixo ou uma string que corresponda a um valor de atributo de resultado anterior dentro do mesmo elemento <filter>. Se nenhum valor for fornecido e esta for a primeira primitiva de filtro, essa primitiva de filtro usará SourceGraphic como sua entrada. Se nenhum valor for fornecido e esta for uma primitiva de filtro subsequente, essa primitiva de filtro usará o resultado da primitiva de filtro anterior como sua entrada.

Se o valor do resultado aparecer várias vezes em um determinado elemento <filter>, uma referência à esse resultado usará a primitiva de filtro anterior mais próxima com o valor fornecido para o resultado do atributo.

func (*TagSvgFeConvolveMatrix) Init 

func (e *TagSvgFeConvolveMatrix) Init() (ref *TagSvgFeConvolveMatrix)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgFeConvolveMatrix) KernelMatrix 

func (e *TagSvgFeConvolveMatrix) KernelMatrix(value interface{}) (ref *TagSvgFeConvolveMatrix)

KernelMatrix

English:

The kernelMatrix attribute defines the list of numbers that make up the kernel matrix for the <feConvolveMatrix> element. 

Input:
  kernelMatrix: list of numbers
    []float64: []float64{1, 1, 0, 0, 0, 0, 0, 0, -1} = "1 1 0 0 0 0 0 0 -1"
    any other type: interface{}

The list of <number>s that make up the kernel matrix for the convolution. The number of entries in the list must equal <orderX> times <orderY>. If the result of orderX * orderY is not equal to the number of entries in the value list, the filter primitive acts as a pass through filter.

Values are separated by space characters and/or a comma. The number of entries in the list must equal to <orderX> by <orderY> as defined in the order attribute.

Português:

O atributo kernelMatrix define a lista de números que compõem a matriz do kernel para o elemento <feConvolveMatrix>. 

Entrada:
  kernelMatrix: lista de números
    []float64: []float64{1, 1, 0, 0, 0, 0, 0, 0, -1} = "1 1 0 0 0 0 0 0 -1"
    any other type: interface{}

A lista de números que compõem a matriz do kernel para a convolução. O número de entradas na lista deve ser igual a <orderX> * <orderY>. Se o resultado da ordem do pedido não for igual ao número de entradas na lista de valores, a primitiva de filtro atua como um filtro de passagem.

Os valores são separados por caracteres de espaço e ou por vírgula. O número de entradas na lista deve ser igual a <orderX> por <orderY> conforme definido no atributo order.

func (*TagSvgFeConvolveMatrix) Lang 

func (e *TagSvgFeConvolveMatrix) Lang(value interface{}) (ref *TagSvgFeConvolveMatrix)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgFeConvolveMatrix) LetterSpacing 

func (e *TagSvgFeConvolveMatrix) LetterSpacing(value float64) (ref *TagSvgFeConvolveMatrix)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgFeConvolveMatrix) LightingColor 

func (e *TagSvgFeConvolveMatrix) LightingColor(value interface{}) (ref *TagSvgFeConvolveMatrix)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgFeConvolveMatrix) MarkerEnd 

func (e *TagSvgFeConvolveMatrix) MarkerEnd(value interface{}) (ref *TagSvgFeConvolveMatrix)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgFeConvolveMatrix) MarkerMid 

func (e *TagSvgFeConvolveMatrix) MarkerMid(value interface{}) (ref *TagSvgFeConvolveMatrix)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgFeConvolveMatrix) MarkerStart 

func (e *TagSvgFeConvolveMatrix) MarkerStart(value interface{}) (ref *TagSvgFeConvolveMatrix)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgFeConvolveMatrix) Mask 

func (e *TagSvgFeConvolveMatrix) Mask(value interface{}) (ref *TagSvgFeConvolveMatrix)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgFeConvolveMatrix) Opacity 

func (e *TagSvgFeConvolveMatrix) Opacity(value interface{}) (ref *TagSvgFeConvolveMatrix)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgFeConvolveMatrix) Order 

func (e *TagSvgFeConvolveMatrix) Order(value interface{}) (ref *TagSvgFeConvolveMatrix)

Order

English:

The order attribute indicates the size of the matrix to be used by a <feConvolveMatrix> element. 

Input:
  value: indicates the size of the matrix.
    []float64: []float64{1.0, 1.0, 1.0} = "1 1 1"
    any other type: interface{}

Português:

O atributo order indica o tamanho da matriz a ser usada por um elemento <feConvolveMatrix>. 

Entrada:
  value: indica o tamanho da matriz.
    []float64: []float64{1.0, 1.0, 1.0} = "1 1 1"
    qualquer outro tipo: interface{}

func (*TagSvgFeConvolveMatrix) Overflow 

func (e *TagSvgFeConvolveMatrix) Overflow(value interface{}) (ref *TagSvgFeConvolveMatrix)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgFeConvolveMatrix) PointerEvents 

func (e *TagSvgFeConvolveMatrix) PointerEvents(value interface{}) (ref *TagSvgFeConvolveMatrix)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgFeConvolveMatrix) PreserveAlpha 

func (e *TagSvgFeConvolveMatrix) PreserveAlpha(value bool) (ref *TagSvgFeConvolveMatrix)

PreserveAlpha

English:

The preserveAlpha attribute indicates how a <feConvolveMatrix> element handled alpha transparency. 

Input:
  value: indicates how handled alpha transparency.

Português:

O atributo preserveAlpha indica como um elemento <feConvolveMatrix> trata a transparência alfa. 

Input:
  value: indica como a transparência alfa é tratada.

func (*TagSvgFeConvolveMatrix) Result 

func (e *TagSvgFeConvolveMatrix) Result(value interface{}) (ref *TagSvgFeConvolveMatrix)

Result

English:

The result attribute defines the assigned name for this filter primitive. If supplied, then graphics that result from processing this filter primitive can be referenced by an in attribute on a subsequent filter primitive within the same <filter> element. If no value is provided, the output will only be available for re-use as the implicit input into the next filter primitive if that filter primitive provides no value for its in attribute.

Português:

O atributo result define o nome atribuído para esta primitiva de filtro. Se fornecido, os gráficos resultantes do processamento dessa primitiva de filtro podem ser referenciados por um atributo in em uma primitiva de filtro subsequente dentro do mesmo elemento <filter>. Se nenhum valor for fornecido, a saída só estará disponível para reutilização como entrada implícita na próxima primitiva de filtro se essa primitiva de filtro não fornecer valor para seu atributo in.

func (*TagSvgFeConvolveMatrix) ShapeRendering 

func (e *TagSvgFeConvolveMatrix) ShapeRendering(value interface{}) (ref *TagSvgFeConvolveMatrix)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgFeConvolveMatrix) StopColor 

func (e *TagSvgFeConvolveMatrix) StopColor(value interface{}) (ref *TagSvgFeConvolveMatrix)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgFeConvolveMatrix) StopOpacity 

func (e *TagSvgFeConvolveMatrix) StopOpacity(value interface{}) (ref *TagSvgFeConvolveMatrix)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgFeConvolveMatrix) Stroke 

func (e *TagSvgFeConvolveMatrix) Stroke(value interface{}) (ref *TagSvgFeConvolveMatrix)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgFeConvolveMatrix) StrokeDasharray 

func (e *TagSvgFeConvolveMatrix) StrokeDasharray(value interface{}) (ref *TagSvgFeConvolveMatrix)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgFeConvolveMatrix) StrokeLineCap 

func (e *TagSvgFeConvolveMatrix) StrokeLineCap(value interface{}) (ref *TagSvgFeConvolveMatrix)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgFeConvolveMatrix) StrokeLineJoin 

func (e *TagSvgFeConvolveMatrix) StrokeLineJoin(value interface{}) (ref *TagSvgFeConvolveMatrix)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgFeConvolveMatrix) StrokeMiterLimit 

func (e *TagSvgFeConvolveMatrix) StrokeMiterLimit(value float64) (ref *TagSvgFeConvolveMatrix)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgFeConvolveMatrix) StrokeOpacity 

func (e *TagSvgFeConvolveMatrix) StrokeOpacity(value interface{}) (ref *TagSvgFeConvolveMatrix)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgFeConvolveMatrix) StrokeWidth 

func (e *TagSvgFeConvolveMatrix) StrokeWidth(value interface{}) (ref *TagSvgFeConvolveMatrix)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeConvolveMatrix) Style 

func (e *TagSvgFeConvolveMatrix) Style(value string) (ref *TagSvgFeConvolveMatrix)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgFeConvolveMatrix) Tabindex 

func (e *TagSvgFeConvolveMatrix) Tabindex(value int) (ref *TagSvgFeConvolveMatrix)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgFeConvolveMatrix) TargetX 

func (e *TagSvgFeConvolveMatrix) TargetX(value int) (ref *TagSvgFeConvolveMatrix)

TargetX

English:

The targetX attribute determines the positioning in horizontal direction of the convolution matrix relative to a given target pixel in the input image. The leftmost column of the matrix is column number zero. The value must be such that: 0 <= targetX < orderX. 

Input:
  value: determines the positioning in horizontal direction

Português:

O atributo targetX determina o posicionamento na direção horizontal da matriz de convolução em relação a um determinado pixel alvo na imagem de entrada. A coluna mais à esquerda da matriz é a coluna número zero. O valor deve ser tal que: 0 <= targetX < orderX. 

Entrada:
  value: determina o posicionamento na direção horizontal

func (*TagSvgFeConvolveMatrix) TargetY 

func (e *TagSvgFeConvolveMatrix) TargetY(value int) (ref *TagSvgFeConvolveMatrix)

TargetY

English:

The targetY attribute determines the positioning in vertical direction of the convolution matrix relative to a given target pixel in the input image. The topmost row of the matrix is row number zero. The value must be such that: 0 <= targetY < orderY. 

Input:
  value: determines the positioning in vertical direction

Português:

O atributo targetY determina o posicionamento na direção vertical da matriz de convolução em relação a um determinado pixel alvo na imagem de entrada. A linha superior da matriz é a linha número zero. O valor deve ser tal que: 0 <= targetY < orderY. 

Entrada:
  value: determines the positioning in vertical direction

func (*TagSvgFeConvolveMatrix) Text 

func (e *TagSvgFeConvolveMatrix) Text(value string) (ref *TagSvgFeConvolveMatrix)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgFeConvolveMatrix) TextAnchor 

func (e *TagSvgFeConvolveMatrix) TextAnchor(value interface{}) (ref *TagSvgFeConvolveMatrix)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgFeConvolveMatrix) TextDecoration 

func (e *TagSvgFeConvolveMatrix) TextDecoration(value interface{}) (ref *TagSvgFeConvolveMatrix)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgFeConvolveMatrix) TextRendering 

func (e *TagSvgFeConvolveMatrix) TextRendering(value interface{}) (ref *TagSvgFeConvolveMatrix)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgFeConvolveMatrix) Transform 

func (e *TagSvgFeConvolveMatrix) Transform(value interface{}) (ref *TagSvgFeConvolveMatrix)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgFeConvolveMatrix) UnicodeBidi 

func (e *TagSvgFeConvolveMatrix) UnicodeBidi(value interface{}) (ref *TagSvgFeConvolveMatrix)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgFeConvolveMatrix) VectorEffect 

func (e *TagSvgFeConvolveMatrix) VectorEffect(value interface{}) (ref *TagSvgFeConvolveMatrix)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgFeConvolveMatrix) Visibility 

func (e *TagSvgFeConvolveMatrix) Visibility(value interface{}) (ref *TagSvgFeConvolveMatrix)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgFeConvolveMatrix) Width 

func (e *TagSvgFeConvolveMatrix) Width(value interface{}) (ref *TagSvgFeConvolveMatrix)

Width

English:

The width attribute defines the horizontal length of an element in the user coordinate system. 

Input:
  value: the horizontal length of an element
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo largura define o comprimento horizontal de um elemento no sistema de coordenadas do usuário. 

Entrada:
  value: o comprimento horizontal de um elemento
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeConvolveMatrix) WordSpacing 

func (e *TagSvgFeConvolveMatrix) WordSpacing(value interface{}) (ref *TagSvgFeConvolveMatrix)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgFeConvolveMatrix) WritingMode 

func (e *TagSvgFeConvolveMatrix) WritingMode(value interface{}) (ref *TagSvgFeConvolveMatrix)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgFeConvolveMatrix) X 

func (e *TagSvgFeConvolveMatrix) X(value interface{}) (ref *TagSvgFeConvolveMatrix)

X

English:

The x attribute defines an x-axis coordinate in the user coordinate system. 

Input:
  value: defines an x-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo x define uma coordenada do eixo x no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo x
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgFeConvolveMatrix) XmlLang 

func (e *TagSvgFeConvolveMatrix) XmlLang(value interface{}) (ref *TagSvgFeConvolveMatrix)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

func (*TagSvgFeConvolveMatrix) Y 

func (e *TagSvgFeConvolveMatrix) Y(value interface{}) (ref *TagSvgFeConvolveMatrix)

Y

English:

The y attribute defines an y-axis coordinate in the user coordinate system. 

Input:
  value: defines an y-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo y define uma coordenada do eixo y no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo y
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

type TagSvgFeDiffuseLighting 

type TagSvgFeDiffuseLighting struct {
	// contains filtered or unexported fields
}

TagSvgFeDiffuseLighting

English:

The <feDiffuseLighting> SVG filter primitive lights an image using the alpha channel as a bump map. The resulting image, which is an RGBA opaque image, depends on the light color, light position and surface geometry of the input bump map.

The light map produced by this filter primitive can be combined with a texture image using the multiply term of the arithmetic operator of the <feComposite> filter primitive. Multiple light sources can be simulated by adding several of these light maps together before applying it to the texture image.

Português:

A primitiva de filtro SVG <feDiffuseLighting> ilumina uma imagem usando o canal alfa como um mapa de relevo. A imagem resultante, que é uma imagem opaca RGBA, depende da cor da luz, posição da luz e geometria da superfície do mapa de relevo de entrada.

O mapa de luz produzido por esta primitiva de filtro pode ser combinado com uma imagem de textura usando o termo multiplicar do operador aritmético da primitiva de filtro <feComposite>. Várias fontes de luz podem ser simuladas adicionando vários desses mapas de luz antes de aplicá-los à imagem de textura.

func (*TagSvgFeDiffuseLighting) Append 

func (e *TagSvgFeDiffuseLighting) Append(elements ...Compatible) (ref *TagSvgFeDiffuseLighting)

func (*TagSvgFeDiffuseLighting) AppendById 

func (e *TagSvgFeDiffuseLighting) AppendById(appendId string) (ref *TagSvgFeDiffuseLighting)

func (*TagSvgFeDiffuseLighting) AppendToElement 

func (e *TagSvgFeDiffuseLighting) AppendToElement(el js.Value) (ref *TagSvgFeDiffuseLighting)

func (*TagSvgFeDiffuseLighting) AppendToStage 

func (e *TagSvgFeDiffuseLighting) AppendToStage() (ref *TagSvgFeDiffuseLighting)

func (*TagSvgFeDiffuseLighting) BaselineShift 

func (e *TagSvgFeDiffuseLighting) BaselineShift(baselineShift interface{}) (ref *TagSvgFeDiffuseLighting)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgFeDiffuseLighting) Class 

func (e *TagSvgFeDiffuseLighting) Class(class string) (ref *TagSvgFeDiffuseLighting)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgFeDiffuseLighting) ClipPath 

func (e *TagSvgFeDiffuseLighting) ClipPath(clipPath string) (ref *TagSvgFeDiffuseLighting)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgFeDiffuseLighting) ClipRule 

func (e *TagSvgFeDiffuseLighting) ClipRule(value interface{}) (ref *TagSvgFeDiffuseLighting)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgFeDiffuseLighting) Color 

func (e *TagSvgFeDiffuseLighting) Color(value interface{}) (ref *TagSvgFeDiffuseLighting)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgFeDiffuseLighting) ColorInterpolation 

func (e *TagSvgFeDiffuseLighting) ColorInterpolation(value interface{}) (ref *TagSvgFeDiffuseLighting)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgFeDiffuseLighting) ColorInterpolationFilters 

func (e *TagSvgFeDiffuseLighting) ColorInterpolationFilters(value interface{}) (ref *TagSvgFeDiffuseLighting)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgFeDiffuseLighting) CreateElement 

func (e *TagSvgFeDiffuseLighting) CreateElement() (ref *TagSvgFeDiffuseLighting)

func (*TagSvgFeDiffuseLighting) Cursor 

func (e *TagSvgFeDiffuseLighting) Cursor(cursor SvgCursor) (ref *TagSvgFeDiffuseLighting)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgFeDiffuseLighting) DiffuseConstant 

func (e *TagSvgFeDiffuseLighting) DiffuseConstant(diffuseConstant float64) (ref *TagSvgFeDiffuseLighting)

DiffuseConstant

English: 

The diffuseConstant attribute represents the kd value in the Phong lighting model. In SVG, this can be any
non-negative number.

It's used to determine the final RGB value of a given pixel. The brighter the lighting-color, the smaller this number should be.

Português: 

O atributo difusoConstant representa o valor kd no modelo de iluminação Phong. Em SVG, pode ser qualquer número
não negativo.

É usado para determinar o valor RGB final de um determinado pixel. Quanto mais brilhante a cor da iluminação, menor deve ser esse número.

func (*TagSvgFeDiffuseLighting) Direction 

func (e *TagSvgFeDiffuseLighting) Direction(direction SvgDirection) (ref *TagSvgFeDiffuseLighting)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgFeDiffuseLighting) Display 

func (e *TagSvgFeDiffuseLighting) Display(value interface{}) (ref *TagSvgFeDiffuseLighting)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgFeDiffuseLighting) DominantBaseline 

func (e *TagSvgFeDiffuseLighting) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgFeDiffuseLighting)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgFeDiffuseLighting) Fill 

func (e *TagSvgFeDiffuseLighting) Fill(value interface{}) (ref *TagSvgFeDiffuseLighting)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgFeDiffuseLighting) FillOpacity 

func (e *TagSvgFeDiffuseLighting) FillOpacity(value interface{}) (ref *TagSvgFeDiffuseLighting)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgFeDiffuseLighting) FillRule 

func (e *TagSvgFeDiffuseLighting) FillRule(fillRule SvgFillRule) (ref *TagSvgFeDiffuseLighting)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgFeDiffuseLighting) Filter 

func (e *TagSvgFeDiffuseLighting) Filter(filter string) (ref *TagSvgFeDiffuseLighting)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgFeDiffuseLighting) FloodColor 

func (e *TagSvgFeDiffuseLighting) FloodColor(floodColor interface{}) (ref *TagSvgFeDiffuseLighting)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgFeDiffuseLighting) FloodOpacity 

func (e *TagSvgFeDiffuseLighting) FloodOpacity(floodOpacity float64) (ref *TagSvgFeDiffuseLighting)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgFeDiffuseLighting) FontFamily 

func (e *TagSvgFeDiffuseLighting) FontFamily(fontFamily string) (ref *TagSvgFeDiffuseLighting)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgFeDiffuseLighting) FontSize 

func (e *TagSvgFeDiffuseLighting) FontSize(fontSize interface{}) (ref *TagSvgFeDiffuseLighting)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgFeDiffuseLighting) FontSizeAdjust 

func (e *TagSvgFeDiffuseLighting) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgFeDiffuseLighting)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgFeDiffuseLighting) FontStretch 

func (e *TagSvgFeDiffuseLighting) FontStretch(fontStretch interface{}) (ref *TagSvgFeDiffuseLighting)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgFeDiffuseLighting) FontStyle 

func (e *TagSvgFeDiffuseLighting) FontStyle(fontStyle FontStyleRule) (ref *TagSvgFeDiffuseLighting)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgFeDiffuseLighting) FontVariant 

func (e *TagSvgFeDiffuseLighting) FontVariant(value interface{}) (ref *TagSvgFeDiffuseLighting)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgFeDiffuseLighting) FontWeight 

func (e *TagSvgFeDiffuseLighting) FontWeight(value interface{}) (ref *TagSvgFeDiffuseLighting)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgFeDiffuseLighting) Get 

func (e *TagSvgFeDiffuseLighting) Get() (el js.Value)

func (*TagSvgFeDiffuseLighting) Height 

func (e *TagSvgFeDiffuseLighting) Height(height interface{}) (ref *TagSvgFeDiffuseLighting)

Height

English: 

The height attribute defines the vertical length of an element in the user coordinate system.
     float32: 1.0 = "100%"
     any other type: interface{}

Português: 

O atributo height define o comprimento vertical de um elemento no sistema de coordenadas do usuário.
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

func (*TagSvgFeDiffuseLighting) Html 

func (e *TagSvgFeDiffuseLighting) Html(value string) (ref *TagSvgFeDiffuseLighting)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgFeDiffuseLighting) Id 

func (e *TagSvgFeDiffuseLighting) Id(id string) (ref *TagSvgFeDiffuseLighting)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgFeDiffuseLighting) ImageRendering 

func (e *TagSvgFeDiffuseLighting) ImageRendering(imageRendering string) (ref *TagSvgFeDiffuseLighting)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgFeDiffuseLighting) In 

func (e *TagSvgFeDiffuseLighting) In(in interface{}) (ref *TagSvgFeDiffuseLighting)

In

English: 

The in attribute identifies input for the given filter primitive.

 Input:
   in: identifies input for the given filter primitive.
     KSvgIn... (e.g. KSvgInSourceAlpha)
     any other type: interface{}

The value can be either one of the six keywords defined below, or a string which matches a previous result attribute value within the same <filter> element. If no value is provided and this is the first filter primitive, then this filter primitive will use SourceGraphic as its input. If no value is provided and this is a subsequent filter primitive, then this filter primitive will use the result from the previous filter primitive as its input.

If the value for result appears multiple times within a given <filter> element, then a reference to that result will use the closest preceding filter primitive with the given value for attribute result.

Portuguese 

O atributo in identifica à entrada para a primitiva de filtro fornecida.

 Entrada:
   in: identifica à entrada para a primitiva de filtro fornecida.
     KSvgIn... (e.g. KSvgInSourceAlpha)
     qualquer outro tipo: interface{}

O valor pode ser uma das seis palavras-chave definidas abaixo ou uma string que corresponda a um valor de atributo de resultado anterior dentro do mesmo elemento <filter>. Se nenhum valor for fornecido e esta for a primeira primitiva de filtro, essa primitiva de filtro usará SourceGraphic como sua entrada. Se nenhum valor for fornecido e esta for uma primitiva de filtro subsequente, essa primitiva de filtro usará o resultado da primitiva de filtro anterior como sua entrada.

Se o valor do resultado aparecer várias vezes em um determinado elemento <filter>, uma referência à esse resultado usará a primitiva de filtro anterior mais próxima com o valor fornecido para o resultado do atributo.

func (*TagSvgFeDiffuseLighting) Init 

func (e *TagSvgFeDiffuseLighting) Init() (ref *TagSvgFeDiffuseLighting)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgFeDiffuseLighting) Lang 

func (e *TagSvgFeDiffuseLighting) Lang(value interface{}) (ref *TagSvgFeDiffuseLighting)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgFeDiffuseLighting) LetterSpacing 

func (e *TagSvgFeDiffuseLighting) LetterSpacing(value float64) (ref *TagSvgFeDiffuseLighting)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgFeDiffuseLighting) LightingColor 

func (e *TagSvgFeDiffuseLighting) LightingColor(value interface{}) (ref *TagSvgFeDiffuseLighting)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgFeDiffuseLighting) LimitingConeAngle 

func (e *TagSvgFeDiffuseLighting) LimitingConeAngle(value float64) (ref *TagSvgFeDiffuseLighting)

LimitingConeAngle

English:

The limitingConeAngle attribute represents the angle in degrees between the spot light axis (i.e. the axis between the light source and the point to which it is pointing at) and the spot light cone. So it defines a limiting cone which restricts the region where the light is projected. No light is projected outside the cone. 

Input:
  value: represents the angle in degrees between the spot light axis

Português:

O atributo limitConeAngle representa o ângulo em graus entre o eixo de luz spot (ou seja, o eixo entre a fonte de luz e o ponto para o qual está apontando) e o cone de luz spot. Assim, define um cone limitador que restringe a região onde a luz é projetada. Nenhuma luz é projetada fora do cone. 

Input:
  value: representa o ângulo em graus entre o eixo da luz spot

func (*TagSvgFeDiffuseLighting) MarkerEnd 

func (e *TagSvgFeDiffuseLighting) MarkerEnd(value interface{}) (ref *TagSvgFeDiffuseLighting)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgFeDiffuseLighting) MarkerMid 

func (e *TagSvgFeDiffuseLighting) MarkerMid(value interface{}) (ref *TagSvgFeDiffuseLighting)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgFeDiffuseLighting) MarkerStart 

func (e *TagSvgFeDiffuseLighting) MarkerStart(value interface{}) (ref *TagSvgFeDiffuseLighting)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgFeDiffuseLighting) Mask 

func (e *TagSvgFeDiffuseLighting) Mask(value interface{}) (ref *TagSvgFeDiffuseLighting)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgFeDiffuseLighting) Opacity 

func (e *TagSvgFeDiffuseLighting) Opacity(value interface{}) (ref *TagSvgFeDiffuseLighting)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgFeDiffuseLighting) Overflow 

func (e *TagSvgFeDiffuseLighting) Overflow(value interface{}) (ref *TagSvgFeDiffuseLighting)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgFeDiffuseLighting) PointerEvents 

func (e *TagSvgFeDiffuseLighting) PointerEvents(value interface{}) (ref *TagSvgFeDiffuseLighting)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgFeDiffuseLighting) PointsAtX 

func (e *TagSvgFeDiffuseLighting) PointsAtX(value interface{}) (ref *TagSvgFeDiffuseLighting)

PointsAtX

English:

The pointsAtX attribute represents the x location in the coordinate system established by attribute primitiveUnits on the <filter> element of the point at which the light source is pointing.

Português:

O atributo pointsAtX representa a localização x no sistema de coordenadas estabelecido pelo atributo primitivaUnits no elemento <filter> do ponto para o qual a fonte de luz está apontando.

func (*TagSvgFeDiffuseLighting) PointsAtY 

func (e *TagSvgFeDiffuseLighting) PointsAtY(value interface{}) (ref *TagSvgFeDiffuseLighting)

PointsAtY

English:

The pointsAtY attribute represents the y location in the coordinate system established by attribute primitiveUnits on the <filter> element of the point at which the light source is pointing.

Português:

O atributo pointsAtY representa a localização y no sistema de coordenadas estabelecido pelo atributo primitivaUnits no elemento <filter> do ponto para o qual a fonte de luz está apontando.

func (*TagSvgFeDiffuseLighting) PointsAtZ 

func (e *TagSvgFeDiffuseLighting) PointsAtZ(value interface{}) (ref *TagSvgFeDiffuseLighting)

PointsAtZ

English:

The pointsAtZ attribute represents the y location in the coordinate system established by attribute primitiveUnits on the <filter> element of the point at which the light source is pointing, assuming that, in the initial local coordinate system, the positive z-axis comes out towards the person viewing the content and assuming that one unit along the z-axis equals one unit in x and y. 

Input:
  value: represents the y location in the coordinate system
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo pointsAtZ representa a localização y no sistema de coordenadas estabelecido pelo atributo primitivaUnits no elemento <filter> do ponto em que a fonte de luz está apontando, assumindo que, no sistema de coordenadas local inicial, o eixo z positivo sai em direção a pessoa visualizando o conteúdo e assumindo que uma unidade ao longo do eixo z é igual a uma unidade em x e y. 

Input:
  value: representa a localização y no sistema de coordenadas
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeDiffuseLighting) Result 

func (e *TagSvgFeDiffuseLighting) Result(value interface{}) (ref *TagSvgFeDiffuseLighting)

Result

English:

The result attribute defines the assigned name for this filter primitive. If supplied, then graphics that result from processing this filter primitive can be referenced by an in attribute on a subsequent filter primitive within the same <filter> element. If no value is provided, the output will only be available for re-use as the implicit input into the next filter primitive if that filter primitive provides no value for its in attribute.

Português:

O atributo result define o nome atribuído para esta primitiva de filtro. Se fornecido, os gráficos resultantes do processamento dessa primitiva de filtro podem ser referenciados por um atributo in em uma primitiva de filtro subsequente dentro do mesmo elemento <filter>. Se nenhum valor for fornecido, a saída só estará disponível para reutilização como entrada implícita na próxima primitiva de filtro se essa primitiva de filtro não fornecer valor para seu atributo in.

func (*TagSvgFeDiffuseLighting) ShapeRendering 

func (e *TagSvgFeDiffuseLighting) ShapeRendering(value interface{}) (ref *TagSvgFeDiffuseLighting)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgFeDiffuseLighting) SpecularExponent 

func (e *TagSvgFeDiffuseLighting) SpecularExponent(value float64) (ref *TagSvgFeDiffuseLighting)

SpecularExponent

English:

The specularExponent attribute controls the focus for the light source. The bigger the value the brighter the light.

Português:

O atributo specularExponent controla o foco da fonte de luz. Quanto maior o valor, mais brilhante é a luz.

func (*TagSvgFeDiffuseLighting) StopColor 

func (e *TagSvgFeDiffuseLighting) StopColor(value interface{}) (ref *TagSvgFeDiffuseLighting)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgFeDiffuseLighting) StopOpacity 

func (e *TagSvgFeDiffuseLighting) StopOpacity(value interface{}) (ref *TagSvgFeDiffuseLighting)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgFeDiffuseLighting) Stroke 

func (e *TagSvgFeDiffuseLighting) Stroke(value interface{}) (ref *TagSvgFeDiffuseLighting)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgFeDiffuseLighting) StrokeDasharray 

func (e *TagSvgFeDiffuseLighting) StrokeDasharray(value interface{}) (ref *TagSvgFeDiffuseLighting)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgFeDiffuseLighting) StrokeLineCap 

func (e *TagSvgFeDiffuseLighting) StrokeLineCap(value interface{}) (ref *TagSvgFeDiffuseLighting)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgFeDiffuseLighting) StrokeLineJoin 

func (e *TagSvgFeDiffuseLighting) StrokeLineJoin(value interface{}) (ref *TagSvgFeDiffuseLighting)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgFeDiffuseLighting) StrokeMiterLimit 

func (e *TagSvgFeDiffuseLighting) StrokeMiterLimit(value float64) (ref *TagSvgFeDiffuseLighting)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgFeDiffuseLighting) StrokeOpacity 

func (e *TagSvgFeDiffuseLighting) StrokeOpacity(value interface{}) (ref *TagSvgFeDiffuseLighting)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgFeDiffuseLighting) StrokeWidth 

func (e *TagSvgFeDiffuseLighting) StrokeWidth(value interface{}) (ref *TagSvgFeDiffuseLighting)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeDiffuseLighting) Style 

func (e *TagSvgFeDiffuseLighting) Style(value string) (ref *TagSvgFeDiffuseLighting)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgFeDiffuseLighting) SurfaceScale 

func (e *TagSvgFeDiffuseLighting) SurfaceScale(value float64) (ref *TagSvgFeDiffuseLighting)

SurfaceScale

English:

The surfaceScale attribute represents the height of the surface for a light filter primitive.

Português:

O atributo surfaceScale representa a altura da superfície para uma primitiva de filtro de luz.

func (*TagSvgFeDiffuseLighting) Tabindex 

func (e *TagSvgFeDiffuseLighting) Tabindex(value int) (ref *TagSvgFeDiffuseLighting)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgFeDiffuseLighting) Text 

func (e *TagSvgFeDiffuseLighting) Text(value string) (ref *TagSvgFeDiffuseLighting)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgFeDiffuseLighting) TextAnchor 

func (e *TagSvgFeDiffuseLighting) TextAnchor(value interface{}) (ref *TagSvgFeDiffuseLighting)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgFeDiffuseLighting) TextDecoration 

func (e *TagSvgFeDiffuseLighting) TextDecoration(value interface{}) (ref *TagSvgFeDiffuseLighting)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgFeDiffuseLighting) TextRendering 

func (e *TagSvgFeDiffuseLighting) TextRendering(value interface{}) (ref *TagSvgFeDiffuseLighting)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgFeDiffuseLighting) Transform 

func (e *TagSvgFeDiffuseLighting) Transform(value interface{}) (ref *TagSvgFeDiffuseLighting)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgFeDiffuseLighting) UnicodeBidi 

func (e *TagSvgFeDiffuseLighting) UnicodeBidi(value interface{}) (ref *TagSvgFeDiffuseLighting)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgFeDiffuseLighting) VectorEffect 

func (e *TagSvgFeDiffuseLighting) VectorEffect(value interface{}) (ref *TagSvgFeDiffuseLighting)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgFeDiffuseLighting) Visibility 

func (e *TagSvgFeDiffuseLighting) Visibility(value interface{}) (ref *TagSvgFeDiffuseLighting)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgFeDiffuseLighting) Width 

func (e *TagSvgFeDiffuseLighting) Width(value interface{}) (ref *TagSvgFeDiffuseLighting)

Width

English:

The width attribute defines the horizontal length of an element in the user coordinate system. 

Input:
  value: the horizontal length of an element
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo largura define o comprimento horizontal de um elemento no sistema de coordenadas do usuário. 

Entrada:
  value: o comprimento horizontal de um elemento
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeDiffuseLighting) WordSpacing 

func (e *TagSvgFeDiffuseLighting) WordSpacing(value interface{}) (ref *TagSvgFeDiffuseLighting)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgFeDiffuseLighting) WritingMode 

func (e *TagSvgFeDiffuseLighting) WritingMode(value interface{}) (ref *TagSvgFeDiffuseLighting)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgFeDiffuseLighting) X 

func (e *TagSvgFeDiffuseLighting) X(value interface{}) (ref *TagSvgFeDiffuseLighting)

X

English:

The x attribute defines an x-axis coordinate in the user coordinate system. 

Input:
  value: defines an x-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo x define uma coordenada do eixo x no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo x
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgFeDiffuseLighting) XmlLang 

func (e *TagSvgFeDiffuseLighting) XmlLang(value interface{}) (ref *TagSvgFeDiffuseLighting)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

func (*TagSvgFeDiffuseLighting) Y 

func (e *TagSvgFeDiffuseLighting) Y(value interface{}) (ref *TagSvgFeDiffuseLighting)

Y

English:

The y attribute defines an y-axis coordinate in the user coordinate system. 

Input:
  value: defines an y-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo y define uma coordenada do eixo y no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo y
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

type TagSvgFeDisplacementMap 

type TagSvgFeDisplacementMap struct {
	// contains filtered or unexported fields
}

TagSvgFeDisplacementMap

English:

The <feDisplacementMap> SVG filter primitive uses the pixel values from the image from in2 to spatially displace the image from in.

The formula for the transformation looks like this:

P'(x,y) ← P( x + scale * (XC(x,y) - 0.5), y + scale * (YC(x,y) - 0.5))

where P(x,y) is the input image, in, and P'(x,y) is the destination. XC(x,y) and YC(x,y) are the component values of the channel designated by xChannelSelector and yChannelSelector.

Português:

A primitiva de filtro SVG <feDisplacementMap> usa os valores de pixel da imagem de in2 para deslocar espacialmente a imagem de in.

A fórmula da transformação fica assim:

P'(x,y) ← P( x + scale * (XC(x,y) - 0.5), y + scale * (YC(x,y) - 0.5))

onde P(x,y) é a imagem de entrada, in, e P'(x,y) é o destino. XC(x,y) e YC(x,y) são os valores componentes do canal designado por xChannelSelector e yChannelSelector.

func (*TagSvgFeDisplacementMap) Append 

func (e *TagSvgFeDisplacementMap) Append(elements ...Compatible) (ref *TagSvgFeDisplacementMap)

func (*TagSvgFeDisplacementMap) AppendById 

func (e *TagSvgFeDisplacementMap) AppendById(appendId string) (ref *TagSvgFeDisplacementMap)

func (*TagSvgFeDisplacementMap) AppendToElement 

func (e *TagSvgFeDisplacementMap) AppendToElement(el js.Value) (ref *TagSvgFeDisplacementMap)

func (*TagSvgFeDisplacementMap) AppendToStage 

func (e *TagSvgFeDisplacementMap) AppendToStage() (ref *TagSvgFeDisplacementMap)

func (*TagSvgFeDisplacementMap) BaselineShift 

func (e *TagSvgFeDisplacementMap) BaselineShift(baselineShift interface{}) (ref *TagSvgFeDisplacementMap)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgFeDisplacementMap) Class 

func (e *TagSvgFeDisplacementMap) Class(class string) (ref *TagSvgFeDisplacementMap)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgFeDisplacementMap) ClipPath 

func (e *TagSvgFeDisplacementMap) ClipPath(clipPath string) (ref *TagSvgFeDisplacementMap)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgFeDisplacementMap) ClipRule 

func (e *TagSvgFeDisplacementMap) ClipRule(value interface{}) (ref *TagSvgFeDisplacementMap)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgFeDisplacementMap) Color 

func (e *TagSvgFeDisplacementMap) Color(value interface{}) (ref *TagSvgFeDisplacementMap)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgFeDisplacementMap) ColorInterpolation 

func (e *TagSvgFeDisplacementMap) ColorInterpolation(value interface{}) (ref *TagSvgFeDisplacementMap)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgFeDisplacementMap) ColorInterpolationFilters 

func (e *TagSvgFeDisplacementMap) ColorInterpolationFilters(value interface{}) (ref *TagSvgFeDisplacementMap)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgFeDisplacementMap) CreateElement 

func (e *TagSvgFeDisplacementMap) CreateElement() (ref *TagSvgFeDisplacementMap)

func (*TagSvgFeDisplacementMap) Cursor 

func (e *TagSvgFeDisplacementMap) Cursor(cursor SvgCursor) (ref *TagSvgFeDisplacementMap)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgFeDisplacementMap) Direction 

func (e *TagSvgFeDisplacementMap) Direction(direction SvgDirection) (ref *TagSvgFeDisplacementMap)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgFeDisplacementMap) Display 

func (e *TagSvgFeDisplacementMap) Display(value interface{}) (ref *TagSvgFeDisplacementMap)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgFeDisplacementMap) DominantBaseline 

func (e *TagSvgFeDisplacementMap) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgFeDisplacementMap)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgFeDisplacementMap) Fill 

func (e *TagSvgFeDisplacementMap) Fill(value interface{}) (ref *TagSvgFeDisplacementMap)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgFeDisplacementMap) FillOpacity 

func (e *TagSvgFeDisplacementMap) FillOpacity(value interface{}) (ref *TagSvgFeDisplacementMap)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgFeDisplacementMap) FillRule 

func (e *TagSvgFeDisplacementMap) FillRule(fillRule SvgFillRule) (ref *TagSvgFeDisplacementMap)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgFeDisplacementMap) Filter 

func (e *TagSvgFeDisplacementMap) Filter(filter string) (ref *TagSvgFeDisplacementMap)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgFeDisplacementMap) FloodColor 

func (e *TagSvgFeDisplacementMap) FloodColor(floodColor interface{}) (ref *TagSvgFeDisplacementMap)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgFeDisplacementMap) FloodOpacity 

func (e *TagSvgFeDisplacementMap) FloodOpacity(floodOpacity float64) (ref *TagSvgFeDisplacementMap)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgFeDisplacementMap) FontFamily 

func (e *TagSvgFeDisplacementMap) FontFamily(fontFamily string) (ref *TagSvgFeDisplacementMap)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgFeDisplacementMap) FontSize 

func (e *TagSvgFeDisplacementMap) FontSize(fontSize interface{}) (ref *TagSvgFeDisplacementMap)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgFeDisplacementMap) FontSizeAdjust 

func (e *TagSvgFeDisplacementMap) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgFeDisplacementMap)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgFeDisplacementMap) FontStretch 

func (e *TagSvgFeDisplacementMap) FontStretch(fontStretch interface{}) (ref *TagSvgFeDisplacementMap)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgFeDisplacementMap) FontStyle 

func (e *TagSvgFeDisplacementMap) FontStyle(fontStyle FontStyleRule) (ref *TagSvgFeDisplacementMap)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgFeDisplacementMap) FontVariant 

func (e *TagSvgFeDisplacementMap) FontVariant(value interface{}) (ref *TagSvgFeDisplacementMap)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgFeDisplacementMap) FontWeight 

func (e *TagSvgFeDisplacementMap) FontWeight(value interface{}) (ref *TagSvgFeDisplacementMap)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgFeDisplacementMap) Get 

func (e *TagSvgFeDisplacementMap) Get() (el js.Value)

func (*TagSvgFeDisplacementMap) Height 

func (e *TagSvgFeDisplacementMap) Height(height interface{}) (ref *TagSvgFeDisplacementMap)

Height

English: 

The height attribute defines the vertical length of an element in the user coordinate system.
     float32: 1.0 = "100%"
     any other type: interface{}

Português: 

O atributo height define o comprimento vertical de um elemento no sistema de coordenadas do usuário.
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

func (*TagSvgFeDisplacementMap) Html 

func (e *TagSvgFeDisplacementMap) Html(value string) (ref *TagSvgFeDisplacementMap)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgFeDisplacementMap) Id 

func (e *TagSvgFeDisplacementMap) Id(id string) (ref *TagSvgFeDisplacementMap)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgFeDisplacementMap) ImageRendering 

func (e *TagSvgFeDisplacementMap) ImageRendering(imageRendering string) (ref *TagSvgFeDisplacementMap)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgFeDisplacementMap) In 

func (e *TagSvgFeDisplacementMap) In(in interface{}) (ref *TagSvgFeDisplacementMap)

In

English: 

The in attribute identifies input for the given filter primitive.

 Input:
   in: identifies input for the given filter primitive.
     KSvgIn... (e.g. KSvgInSourceAlpha)
     any other type: interface{}

The value can be either one of the six keywords defined below, or a string which matches a previous result attribute value within the same <filter> element. If no value is provided and this is the first filter primitive, then this filter primitive will use SourceGraphic as its input. If no value is provided and this is a subsequent filter primitive, then this filter primitive will use the result from the previous filter primitive as its input.

If the value for result appears multiple times within a given <filter> element, then a reference to that result will use the closest preceding filter primitive with the given value for attribute result.

Portuguese 

O atributo in identifica à entrada para a primitiva de filtro fornecida.

 Entrada:
   in: identifica à entrada para a primitiva de filtro fornecida.
     KSvgIn... (e.g. KSvgInSourceAlpha)
     qualquer outro tipo: interface{}

O valor pode ser uma das seis palavras-chave definidas abaixo ou uma string que corresponda a um valor de atributo de resultado anterior dentro do mesmo elemento <filter>. Se nenhum valor for fornecido e esta for a primeira primitiva de filtro, essa primitiva de filtro usará SourceGraphic como sua entrada. Se nenhum valor for fornecido e esta for uma primitiva de filtro subsequente, essa primitiva de filtro usará o resultado da primitiva de filtro anterior como sua entrada.

Se o valor do resultado aparecer várias vezes em um determinado elemento <filter>, uma referência à esse resultado usará a primitiva de filtro anterior mais próxima com o valor fornecido para o resultado do atributo.

func (*TagSvgFeDisplacementMap) In2 

func (e *TagSvgFeDisplacementMap) In2(in2 interface{}) (ref *TagSvgFeDisplacementMap)

In2

English: 

The in2 attribute identifies the second input for the given filter primitive. It works exactly like the in
attribute.

 Input:
   in2: identifies the second input for the given filter primitive.
     KSvgIn2... (e.g. KSvgIn2SourceAlpha)
     string: url(#myClip)
     any other type: interface{}

Portuguese 

O atributo in2 identifica a segunda entrada para a primitiva de filtro fornecida. Funciona exatamente como o
atributo in.

 Entrada:
   in2: identifica a segunda entrada para a primitiva de filtro fornecida.
     KSvgIn2... (ex. KSvgIn2SourceAlpha)
     string: url(#myClip)
     qualquer outro tipo: interface{}

func (*TagSvgFeDisplacementMap) Init 

func (e *TagSvgFeDisplacementMap) Init() (ref *TagSvgFeDisplacementMap)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgFeDisplacementMap) Lang 

func (e *TagSvgFeDisplacementMap) Lang(value interface{}) (ref *TagSvgFeDisplacementMap)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgFeDisplacementMap) LetterSpacing 

func (e *TagSvgFeDisplacementMap) LetterSpacing(value float64) (ref *TagSvgFeDisplacementMap)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgFeDisplacementMap) LightingColor 

func (e *TagSvgFeDisplacementMap) LightingColor(value interface{}) (ref *TagSvgFeDisplacementMap)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgFeDisplacementMap) MarkerEnd 

func (e *TagSvgFeDisplacementMap) MarkerEnd(value interface{}) (ref *TagSvgFeDisplacementMap)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgFeDisplacementMap) MarkerMid 

func (e *TagSvgFeDisplacementMap) MarkerMid(value interface{}) (ref *TagSvgFeDisplacementMap)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgFeDisplacementMap) MarkerStart 

func (e *TagSvgFeDisplacementMap) MarkerStart(value interface{}) (ref *TagSvgFeDisplacementMap)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgFeDisplacementMap) Mask 

func (e *TagSvgFeDisplacementMap) Mask(value interface{}) (ref *TagSvgFeDisplacementMap)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgFeDisplacementMap) Opacity 

func (e *TagSvgFeDisplacementMap) Opacity(value interface{}) (ref *TagSvgFeDisplacementMap)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgFeDisplacementMap) Overflow 

func (e *TagSvgFeDisplacementMap) Overflow(value interface{}) (ref *TagSvgFeDisplacementMap)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgFeDisplacementMap) PointerEvents 

func (e *TagSvgFeDisplacementMap) PointerEvents(value interface{}) (ref *TagSvgFeDisplacementMap)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgFeDisplacementMap) Result 

func (e *TagSvgFeDisplacementMap) Result(value interface{}) (ref *TagSvgFeDisplacementMap)

Result

English:

The result attribute defines the assigned name for this filter primitive. If supplied, then graphics that result from processing this filter primitive can be referenced by an in attribute on a subsequent filter primitive within the same <filter> element. If no value is provided, the output will only be available for re-use as the implicit input into the next filter primitive if that filter primitive provides no value for its in attribute.

Português:

O atributo result define o nome atribuído para esta primitiva de filtro. Se fornecido, os gráficos resultantes do processamento dessa primitiva de filtro podem ser referenciados por um atributo in em uma primitiva de filtro subsequente dentro do mesmo elemento <filter>. Se nenhum valor for fornecido, a saída só estará disponível para reutilização como entrada implícita na próxima primitiva de filtro se essa primitiva de filtro não fornecer valor para seu atributo in.

func (*TagSvgFeDisplacementMap) Scale 

func (e *TagSvgFeDisplacementMap) Scale(value float64) (ref *TagSvgFeDisplacementMap)

Scale

English:

The scale attribute defines the displacement scale factor to be used on a <feDisplacementMap> filter primitive. The amount is expressed in the coordinate system established by the primitiveUnits attribute on the <filter> element.

Português:

O atributo scale define o fator de escala de deslocamento a ser usado em uma primitiva de filtro <feDisplacementMap>. A quantidade é expressa no sistema de coordenadas estabelecido pelo atributo primitivaUnits no elemento <filter>.

func (*TagSvgFeDisplacementMap) ShapeRendering 

func (e *TagSvgFeDisplacementMap) ShapeRendering(value interface{}) (ref *TagSvgFeDisplacementMap)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgFeDisplacementMap) StopColor 

func (e *TagSvgFeDisplacementMap) StopColor(value interface{}) (ref *TagSvgFeDisplacementMap)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgFeDisplacementMap) StopOpacity 

func (e *TagSvgFeDisplacementMap) StopOpacity(value interface{}) (ref *TagSvgFeDisplacementMap)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgFeDisplacementMap) Stroke 

func (e *TagSvgFeDisplacementMap) Stroke(value interface{}) (ref *TagSvgFeDisplacementMap)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgFeDisplacementMap) StrokeDasharray 

func (e *TagSvgFeDisplacementMap) StrokeDasharray(value interface{}) (ref *TagSvgFeDisplacementMap)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgFeDisplacementMap) StrokeLineCap 

func (e *TagSvgFeDisplacementMap) StrokeLineCap(value interface{}) (ref *TagSvgFeDisplacementMap)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgFeDisplacementMap) StrokeLineJoin 

func (e *TagSvgFeDisplacementMap) StrokeLineJoin(value interface{}) (ref *TagSvgFeDisplacementMap)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgFeDisplacementMap) StrokeMiterLimit 

func (e *TagSvgFeDisplacementMap) StrokeMiterLimit(value float64) (ref *TagSvgFeDisplacementMap)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgFeDisplacementMap) StrokeOpacity 

func (e *TagSvgFeDisplacementMap) StrokeOpacity(value interface{}) (ref *TagSvgFeDisplacementMap)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgFeDisplacementMap) StrokeWidth 

func (e *TagSvgFeDisplacementMap) StrokeWidth(value interface{}) (ref *TagSvgFeDisplacementMap)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeDisplacementMap) Style 

func (e *TagSvgFeDisplacementMap) Style(value string) (ref *TagSvgFeDisplacementMap)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgFeDisplacementMap) Tabindex 

func (e *TagSvgFeDisplacementMap) Tabindex(value int) (ref *TagSvgFeDisplacementMap)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgFeDisplacementMap) Text 

func (e *TagSvgFeDisplacementMap) Text(value string) (ref *TagSvgFeDisplacementMap)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgFeDisplacementMap) TextAnchor 

func (e *TagSvgFeDisplacementMap) TextAnchor(value interface{}) (ref *TagSvgFeDisplacementMap)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgFeDisplacementMap) TextDecoration 

func (e *TagSvgFeDisplacementMap) TextDecoration(value interface{}) (ref *TagSvgFeDisplacementMap)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgFeDisplacementMap) TextRendering 

func (e *TagSvgFeDisplacementMap) TextRendering(value interface{}) (ref *TagSvgFeDisplacementMap)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgFeDisplacementMap) Transform 

func (e *TagSvgFeDisplacementMap) Transform(value interface{}) (ref *TagSvgFeDisplacementMap)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgFeDisplacementMap) UnicodeBidi 

func (e *TagSvgFeDisplacementMap) UnicodeBidi(value interface{}) (ref *TagSvgFeDisplacementMap)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgFeDisplacementMap) VectorEffect 

func (e *TagSvgFeDisplacementMap) VectorEffect(value interface{}) (ref *TagSvgFeDisplacementMap)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgFeDisplacementMap) Visibility 

func (e *TagSvgFeDisplacementMap) Visibility(value interface{}) (ref *TagSvgFeDisplacementMap)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgFeDisplacementMap) Width 

func (e *TagSvgFeDisplacementMap) Width(value interface{}) (ref *TagSvgFeDisplacementMap)

Width

English:

The width attribute defines the horizontal length of an element in the user coordinate system. 

Input:
  value: the horizontal length of an element
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo largura define o comprimento horizontal de um elemento no sistema de coordenadas do usuário. 

Entrada:
  value: o comprimento horizontal de um elemento
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeDisplacementMap) WordSpacing 

func (e *TagSvgFeDisplacementMap) WordSpacing(value interface{}) (ref *TagSvgFeDisplacementMap)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgFeDisplacementMap) WritingMode 

func (e *TagSvgFeDisplacementMap) WritingMode(value interface{}) (ref *TagSvgFeDisplacementMap)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgFeDisplacementMap) X 

func (e *TagSvgFeDisplacementMap) X(value interface{}) (ref *TagSvgFeDisplacementMap)

X

English:

The x attribute defines an x-axis coordinate in the user coordinate system. 

Input:
  value: defines an x-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo x define uma coordenada do eixo x no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo x
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgFeDisplacementMap) XChannelSelector 

func (e *TagSvgFeDisplacementMap) XChannelSelector(value interface{}) (ref *TagSvgFeDisplacementMap)

XChannelSelector

English:

The xChannelSelector attribute indicates which color channel from in2 to use to displace the pixels in in along the x-axis. 

Input:
  value: indicates which color channel from in2
    const: KSvgChannelSelector... (e.g. KSvgChannelSelectorR)
    any other type: interface{}

Português:

O atributo xChannelSelector indica qual canal de cor de in2 usar para deslocar os pixels ao longo do eixo x. 

Entrada:
  value: indica qual canal de cor da in2
    const: KSvgChannelSelector... (ex. KSvgChannelSelectorR)
    qualquer outro tipo: interface{}

func (*TagSvgFeDisplacementMap) XmlLang 

func (e *TagSvgFeDisplacementMap) XmlLang(value interface{}) (ref *TagSvgFeDisplacementMap)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

func (*TagSvgFeDisplacementMap) Y 

func (e *TagSvgFeDisplacementMap) Y(value interface{}) (ref *TagSvgFeDisplacementMap)

Y

English:

The y attribute defines an y-axis coordinate in the user coordinate system. 

Input:
  value: defines an y-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo y define uma coordenada do eixo y no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo y
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgFeDisplacementMap) YChannelSelector 

func (e *TagSvgFeDisplacementMap) YChannelSelector(value interface{}) (ref *TagSvgFeDisplacementMap)

YChannelSelector

English:

The yChannelSelector attribute indicates which color channel from in2 to use to displace the pixels in along the y-axis. 

Input:
  value: indicates which color channel from in2
    const: KSvgChannelSelector... (e.g. KSvgChannelSelectorR)
    any other type: interface{}

Português:

O atributo yChannelSelector indica qual canal de cor de in2 usar para deslocar os pixels ao longo do eixo y. 

Entrada:
  value: indica qual canal de cor da in2
    const: KSvgChannelSelector... (ex. KSvgChannelSelectorR)
    qualquer outro tipo: interface{}

type TagSvgFeDistantLight 

type TagSvgFeDistantLight struct {
	// contains filtered or unexported fields
}

TagSvgFeDistantLight

English:

The <feDistantLight> filter primitive defines a distant light source that can be used within a lighting filter primitive: <feDiffuseLighting> or <feSpecularLighting>.

Português:

A primitiva de filtro <feDistantLight> define uma fonte de luz distante que pode ser usada em uma primitiva de filtro de iluminação: <feDiffuseLighting> ou <feSpecularLighting>.

func (*TagSvgFeDistantLight) Append 

func (e *TagSvgFeDistantLight) Append(elements ...Compatible) (ref *TagSvgFeDistantLight)

func (*TagSvgFeDistantLight) AppendById 

func (e *TagSvgFeDistantLight) AppendById(appendId string) (ref *TagSvgFeDistantLight)

func (*TagSvgFeDistantLight) AppendToElement 

func (e *TagSvgFeDistantLight) AppendToElement(el js.Value) (ref *TagSvgFeDistantLight)

func (*TagSvgFeDistantLight) AppendToStage 

func (e *TagSvgFeDistantLight) AppendToStage() (ref *TagSvgFeDistantLight)

func (*TagSvgFeDistantLight) Azimuth 

func (e *TagSvgFeDistantLight) Azimuth(azimuth float64) (ref *TagSvgFeDistantLight)

Azimuth

English: 

The azimuth attribute specifies the direction angle for the light source on the XY plane (clockwise), in degrees
from the x axis.

 Input:
   azimuth: specifies the direction angle for the light source on the XY plane

Português: 

O atributo azimute especifica o ângulo de direção da fonte de luz no plano XY (sentido horário), em graus a partir
do eixo x.

 Input:
   azimuth: especifica o ângulo de direção para a fonte de luz no plano XY

func (*TagSvgFeDistantLight) CreateElement 

func (e *TagSvgFeDistantLight) CreateElement() (ref *TagSvgFeDistantLight)

func (*TagSvgFeDistantLight) Elevation 

func (e *TagSvgFeDistantLight) Elevation(elevation float64) (ref *TagSvgFeDistantLight)

Elevation

English: 

The elevation attribute specifies the direction angle for the light source from the XY plane towards the Z-axis, in
degrees. Note that the positive Z-axis points towards the viewer of the content.

Portuguese 

O atributo de elevação especifica o ângulo de direção da fonte de luz do plano XY em direção ao eixo Z, em graus.
Observe que o eixo Z positivo aponta para o visualizador do conteúdo.

func (*TagSvgFeDistantLight) Get 

func (e *TagSvgFeDistantLight) Get() (el js.Value)

func (*TagSvgFeDistantLight) Html 

func (e *TagSvgFeDistantLight) Html(value string) (ref *TagSvgFeDistantLight)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgFeDistantLight) Id 

func (e *TagSvgFeDistantLight) Id(id string) (ref *TagSvgFeDistantLight)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgFeDistantLight) Init 

func (e *TagSvgFeDistantLight) Init() (ref *TagSvgFeDistantLight)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgFeDistantLight) Lang 

func (e *TagSvgFeDistantLight) Lang(value interface{}) (ref *TagSvgFeDistantLight)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgFeDistantLight) Tabindex 

func (e *TagSvgFeDistantLight) Tabindex(value int) (ref *TagSvgFeDistantLight)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgFeDistantLight) Text 

func (e *TagSvgFeDistantLight) Text(value string) (ref *TagSvgFeDistantLight)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgFeDistantLight) XmlLang 

func (e *TagSvgFeDistantLight) XmlLang(value interface{}) (ref *TagSvgFeDistantLight)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

type TagSvgFeDropShadow 

type TagSvgFeDropShadow struct {
	// contains filtered or unexported fields
}

TagSvgFeDropShadow

English:

The SVG <feDropShadow> filter primitive creates a drop shadow of the input image. It can only be used inside a <filter> element. 

Notes:
  * The drop shadow color and opacity can be changed by using the flood-color and flood-opacity presentation
    attributes.

Português:

A primitiva de filtro SVG <feDropShadow> cria uma sombra projetada da imagem de entrada. Ele só pode ser usado dentro de um elemento <filter>. 

Notas:
  * A cor e a opacidade da sombra projetada podem ser alteradas usando os atributos de apresentação de cor de
    inundação e opacidade de inundação.

func (*TagSvgFeDropShadow) Append 

func (e *TagSvgFeDropShadow) Append(elements ...Compatible) (ref *TagSvgFeDropShadow)

func (*TagSvgFeDropShadow) AppendById 

func (e *TagSvgFeDropShadow) AppendById(appendId string) (ref *TagSvgFeDropShadow)

func (*TagSvgFeDropShadow) AppendToElement 

func (e *TagSvgFeDropShadow) AppendToElement(el js.Value) (ref *TagSvgFeDropShadow)

func (*TagSvgFeDropShadow) AppendToStage 

func (e *TagSvgFeDropShadow) AppendToStage() (ref *TagSvgFeDropShadow)

func (*TagSvgFeDropShadow) BaselineShift 

func (e *TagSvgFeDropShadow) BaselineShift(baselineShift interface{}) (ref *TagSvgFeDropShadow)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgFeDropShadow) Class 

func (e *TagSvgFeDropShadow) Class(class string) (ref *TagSvgFeDropShadow)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgFeDropShadow) ClipPath 

func (e *TagSvgFeDropShadow) ClipPath(clipPath string) (ref *TagSvgFeDropShadow)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgFeDropShadow) ClipRule 

func (e *TagSvgFeDropShadow) ClipRule(value interface{}) (ref *TagSvgFeDropShadow)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgFeDropShadow) Color 

func (e *TagSvgFeDropShadow) Color(value interface{}) (ref *TagSvgFeDropShadow)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgFeDropShadow) ColorInterpolation 

func (e *TagSvgFeDropShadow) ColorInterpolation(value interface{}) (ref *TagSvgFeDropShadow)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgFeDropShadow) ColorInterpolationFilters 

func (e *TagSvgFeDropShadow) ColorInterpolationFilters(value interface{}) (ref *TagSvgFeDropShadow)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgFeDropShadow) CreateElement 

func (e *TagSvgFeDropShadow) CreateElement() (ref *TagSvgFeDropShadow)

func (*TagSvgFeDropShadow) Cursor 

func (e *TagSvgFeDropShadow) Cursor(cursor SvgCursor) (ref *TagSvgFeDropShadow)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgFeDropShadow) Direction 

func (e *TagSvgFeDropShadow) Direction(direction SvgDirection) (ref *TagSvgFeDropShadow)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgFeDropShadow) Display 

func (e *TagSvgFeDropShadow) Display(value interface{}) (ref *TagSvgFeDropShadow)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgFeDropShadow) DominantBaseline 

func (e *TagSvgFeDropShadow) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgFeDropShadow)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgFeDropShadow) Dx 

func (e *TagSvgFeDropShadow) Dx(value interface{}) (ref *TagSvgFeDropShadow)

Dx

English: 

The dx attribute indicates a shift along the x-axis on the position of an element or its content.

 Input:
   dx: indicates a shift along the x-axis on the position of an element or its content.
     []float32: []float64{0.0, 0.1} = "0% 10%"
     []float64: []float64{0.0, 10.0} = "0 10"
     float32: 0.1 = "10%"
     float64: 10.0 = "10"
     any other type: interface{}

Portuguese 

O atributo dx indica um deslocamento ao longo do eixo x na posição de um elemento ou seu conteúdo.

 Entrada:
   dx: indica um deslocamento ao longo do eixo x na posição de um elemento ou seu conteúdo.
     []float32: []float64{0.0, 0.1} = "0% 10%"
     []float64: []float64{0.0, 10.0} = "0 10"
     float32: 0.1 = "10%"
     float64: 10.0 = "10"
     qualquer outro tipo: interface{}

func (*TagSvgFeDropShadow) Dy 

func (e *TagSvgFeDropShadow) Dy(value interface{}) (ref *TagSvgFeDropShadow)

Dy

English: 

The dy attribute indicates a shift along the y-axis on the position of an element or its content.

 Input:
   dy: indicates a shift along the y-axis on the position of an element or its content.
     []float32: []float64{0.0, 0.1} = "0% 10%"
     []float64: []float64{0.0, 10.0} = "0 10"
     float32: 0.1 = "10%"
     float64: 10.0 = "10"
     any other type: interface{}

Portuguese 

O atributo dy indica um deslocamento ao longo do eixo y na posição de um elemento ou seu conteúdo.

 Entrada:
   dy: indica um deslocamento ao longo do eixo y na posição de um elemento ou seu conteúdo.
     []float32: []float64{0.0, 0.1} = "0% 10%"
     []float64: []float64{0.0, 10.0} = "0 10"
     float32: 0.1 = "10%"
     float64: 10.0 = "10"
     qualquer outro tipo: interface{}

func (*TagSvgFeDropShadow) Fill 

func (e *TagSvgFeDropShadow) Fill(value interface{}) (ref *TagSvgFeDropShadow)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgFeDropShadow) FillOpacity 

func (e *TagSvgFeDropShadow) FillOpacity(value interface{}) (ref *TagSvgFeDropShadow)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgFeDropShadow) FillRule 

func (e *TagSvgFeDropShadow) FillRule(fillRule SvgFillRule) (ref *TagSvgFeDropShadow)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgFeDropShadow) Filter 

func (e *TagSvgFeDropShadow) Filter(filter string) (ref *TagSvgFeDropShadow)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgFeDropShadow) FloodColor 

func (e *TagSvgFeDropShadow) FloodColor(floodColor interface{}) (ref *TagSvgFeDropShadow)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgFeDropShadow) FloodOpacity 

func (e *TagSvgFeDropShadow) FloodOpacity(floodOpacity float64) (ref *TagSvgFeDropShadow)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgFeDropShadow) FontFamily 

func (e *TagSvgFeDropShadow) FontFamily(fontFamily string) (ref *TagSvgFeDropShadow)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgFeDropShadow) FontSize 

func (e *TagSvgFeDropShadow) FontSize(fontSize interface{}) (ref *TagSvgFeDropShadow)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgFeDropShadow) FontSizeAdjust 

func (e *TagSvgFeDropShadow) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgFeDropShadow)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgFeDropShadow) FontStretch 

func (e *TagSvgFeDropShadow) FontStretch(fontStretch interface{}) (ref *TagSvgFeDropShadow)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgFeDropShadow) FontStyle 

func (e *TagSvgFeDropShadow) FontStyle(fontStyle FontStyleRule) (ref *TagSvgFeDropShadow)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgFeDropShadow) FontVariant 

func (e *TagSvgFeDropShadow) FontVariant(value interface{}) (ref *TagSvgFeDropShadow)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgFeDropShadow) FontWeight 

func (e *TagSvgFeDropShadow) FontWeight(value interface{}) (ref *TagSvgFeDropShadow)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgFeDropShadow) Get 

func (e *TagSvgFeDropShadow) Get() (el js.Value)

func (*TagSvgFeDropShadow) Height 

func (e *TagSvgFeDropShadow) Height(height interface{}) (ref *TagSvgFeDropShadow)

Height

English: 

The height attribute defines the vertical length of an element in the user coordinate system.
     float32: 1.0 = "100%"
     any other type: interface{}

Português: 

O atributo height define o comprimento vertical de um elemento no sistema de coordenadas do usuário.
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

func (*TagSvgFeDropShadow) Html 

func (e *TagSvgFeDropShadow) Html(value string) (ref *TagSvgFeDropShadow)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgFeDropShadow) Id 

func (e *TagSvgFeDropShadow) Id(id string) (ref *TagSvgFeDropShadow)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgFeDropShadow) ImageRendering 

func (e *TagSvgFeDropShadow) ImageRendering(imageRendering string) (ref *TagSvgFeDropShadow)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgFeDropShadow) Init 

func (e *TagSvgFeDropShadow) Init() (ref *TagSvgFeDropShadow)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgFeDropShadow) Lang 

func (e *TagSvgFeDropShadow) Lang(value interface{}) (ref *TagSvgFeDropShadow)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgFeDropShadow) LetterSpacing 

func (e *TagSvgFeDropShadow) LetterSpacing(value float64) (ref *TagSvgFeDropShadow)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgFeDropShadow) LightingColor 

func (e *TagSvgFeDropShadow) LightingColor(value interface{}) (ref *TagSvgFeDropShadow)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgFeDropShadow) MarkerEnd 

func (e *TagSvgFeDropShadow) MarkerEnd(value interface{}) (ref *TagSvgFeDropShadow)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgFeDropShadow) MarkerMid 

func (e *TagSvgFeDropShadow) MarkerMid(value interface{}) (ref *TagSvgFeDropShadow)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgFeDropShadow) MarkerStart 

func (e *TagSvgFeDropShadow) MarkerStart(value interface{}) (ref *TagSvgFeDropShadow)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgFeDropShadow) Mask 

func (e *TagSvgFeDropShadow) Mask(value interface{}) (ref *TagSvgFeDropShadow)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgFeDropShadow) Opacity 

func (e *TagSvgFeDropShadow) Opacity(value interface{}) (ref *TagSvgFeDropShadow)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgFeDropShadow) Overflow 

func (e *TagSvgFeDropShadow) Overflow(value interface{}) (ref *TagSvgFeDropShadow)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgFeDropShadow) PointerEvents 

func (e *TagSvgFeDropShadow) PointerEvents(value interface{}) (ref *TagSvgFeDropShadow)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgFeDropShadow) Result 

func (e *TagSvgFeDropShadow) Result(value interface{}) (ref *TagSvgFeDropShadow)

Result

English:

The result attribute defines the assigned name for this filter primitive. If supplied, then graphics that result from processing this filter primitive can be referenced by an in attribute on a subsequent filter primitive within the same <filter> element. If no value is provided, the output will only be available for re-use as the implicit input into the next filter primitive if that filter primitive provides no value for its in attribute.

Português:

O atributo result define o nome atribuído para esta primitiva de filtro. Se fornecido, os gráficos resultantes do processamento dessa primitiva de filtro podem ser referenciados por um atributo in em uma primitiva de filtro subsequente dentro do mesmo elemento <filter>. Se nenhum valor for fornecido, a saída só estará disponível para reutilização como entrada implícita na próxima primitiva de filtro se essa primitiva de filtro não fornecer valor para seu atributo in.

func (*TagSvgFeDropShadow) ShapeRendering 

func (e *TagSvgFeDropShadow) ShapeRendering(value interface{}) (ref *TagSvgFeDropShadow)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgFeDropShadow) StdDeviation 

func (e *TagSvgFeDropShadow) StdDeviation(value interface{}) (ref *TagSvgFeDropShadow)

StdDeviation

English:

The stdDeviation attribute defines the standard deviation for the blur operation. 

Input:
  value: defines the standard deviation
    []float64: []float64{2,5} = "2 5"
    any other type: interface{}

Português:

O atributo stdDeviation define o desvio padrão para a operação de desfoque. 

Input:
  value: define o desvio padrão
    []float64: []float64{2,5} = "2 5"
    qualquer outro tipo: interface{}

func (*TagSvgFeDropShadow) StopColor 

func (e *TagSvgFeDropShadow) StopColor(value interface{}) (ref *TagSvgFeDropShadow)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgFeDropShadow) StopOpacity 

func (e *TagSvgFeDropShadow) StopOpacity(value interface{}) (ref *TagSvgFeDropShadow)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgFeDropShadow) Stroke 

func (e *TagSvgFeDropShadow) Stroke(value interface{}) (ref *TagSvgFeDropShadow)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgFeDropShadow) StrokeDasharray 

func (e *TagSvgFeDropShadow) StrokeDasharray(value interface{}) (ref *TagSvgFeDropShadow)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgFeDropShadow) StrokeLineCap 

func (e *TagSvgFeDropShadow) StrokeLineCap(value interface{}) (ref *TagSvgFeDropShadow)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgFeDropShadow) StrokeLineJoin 

func (e *TagSvgFeDropShadow) StrokeLineJoin(value interface{}) (ref *TagSvgFeDropShadow)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgFeDropShadow) StrokeMiterLimit 

func (e *TagSvgFeDropShadow) StrokeMiterLimit(value float64) (ref *TagSvgFeDropShadow)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgFeDropShadow) StrokeOpacity 

func (e *TagSvgFeDropShadow) StrokeOpacity(value interface{}) (ref *TagSvgFeDropShadow)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgFeDropShadow) StrokeWidth 

func (e *TagSvgFeDropShadow) StrokeWidth(value interface{}) (ref *TagSvgFeDropShadow)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeDropShadow) Style 

func (e *TagSvgFeDropShadow) Style(value string) (ref *TagSvgFeDropShadow)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgFeDropShadow) Tabindex 

func (e *TagSvgFeDropShadow) Tabindex(value int) (ref *TagSvgFeDropShadow)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgFeDropShadow) Text 

func (e *TagSvgFeDropShadow) Text(value string) (ref *TagSvgFeDropShadow)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgFeDropShadow) TextAnchor 

func (e *TagSvgFeDropShadow) TextAnchor(value interface{}) (ref *TagSvgFeDropShadow)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgFeDropShadow) TextDecoration 

func (e *TagSvgFeDropShadow) TextDecoration(value interface{}) (ref *TagSvgFeDropShadow)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgFeDropShadow) TextRendering 

func (e *TagSvgFeDropShadow) TextRendering(value interface{}) (ref *TagSvgFeDropShadow)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgFeDropShadow) Transform 

func (e *TagSvgFeDropShadow) Transform(value interface{}) (ref *TagSvgFeDropShadow)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgFeDropShadow) UnicodeBidi 

func (e *TagSvgFeDropShadow) UnicodeBidi(value interface{}) (ref *TagSvgFeDropShadow)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgFeDropShadow) VectorEffect 

func (e *TagSvgFeDropShadow) VectorEffect(value interface{}) (ref *TagSvgFeDropShadow)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgFeDropShadow) Visibility 

func (e *TagSvgFeDropShadow) Visibility(value interface{}) (ref *TagSvgFeDropShadow)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgFeDropShadow) Width 

func (e *TagSvgFeDropShadow) Width(value interface{}) (ref *TagSvgFeDropShadow)

Width

English:

The width attribute defines the horizontal length of an element in the user coordinate system. 

Input:
  value: the horizontal length of an element
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo largura define o comprimento horizontal de um elemento no sistema de coordenadas do usuário. 

Entrada:
  value: o comprimento horizontal de um elemento
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeDropShadow) WordSpacing 

func (e *TagSvgFeDropShadow) WordSpacing(value interface{}) (ref *TagSvgFeDropShadow)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgFeDropShadow) WritingMode 

func (e *TagSvgFeDropShadow) WritingMode(value interface{}) (ref *TagSvgFeDropShadow)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgFeDropShadow) X 

func (e *TagSvgFeDropShadow) X(value interface{}) (ref *TagSvgFeDropShadow)

X

English:

The x attribute defines an x-axis coordinate in the user coordinate system. 

Input:
  value: defines an x-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo x define uma coordenada do eixo x no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo x
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgFeDropShadow) XmlLang 

func (e *TagSvgFeDropShadow) XmlLang(value interface{}) (ref *TagSvgFeDropShadow)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

func (*TagSvgFeDropShadow) Y 

func (e *TagSvgFeDropShadow) Y(value interface{}) (ref *TagSvgFeDropShadow)

Y

English:

The y attribute defines an y-axis coordinate in the user coordinate system. 

Input:
  value: defines an y-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo y define uma coordenada do eixo y no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo y
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

type TagSvgFeFlood 

type TagSvgFeFlood struct {
	// contains filtered or unexported fields
}

TagSvgFeFlood

English:

The <feFlood> SVG filter primitive fills the filter subregion with the color and opacity defined by flood-color and flood-opacity.

Português:

A primitiva de filtro SVG <feFlood> preenche a sub-região do filtro com a cor e a opacidade definidas por flood-color e flood-opacity.

func (*TagSvgFeFlood) Append 

func (e *TagSvgFeFlood) Append(elements ...Compatible) (ref *TagSvgFeFlood)

func (*TagSvgFeFlood) AppendById 

func (e *TagSvgFeFlood) AppendById(appendId string) (ref *TagSvgFeFlood)

func (*TagSvgFeFlood) AppendToElement 

func (e *TagSvgFeFlood) AppendToElement(el js.Value) (ref *TagSvgFeFlood)

func (*TagSvgFeFlood) AppendToStage 

func (e *TagSvgFeFlood) AppendToStage() (ref *TagSvgFeFlood)

func (*TagSvgFeFlood) BaselineShift 

func (e *TagSvgFeFlood) BaselineShift(baselineShift interface{}) (ref *TagSvgFeFlood)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgFeFlood) Class 

func (e *TagSvgFeFlood) Class(class string) (ref *TagSvgFeFlood)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgFeFlood) ClipPath 

func (e *TagSvgFeFlood) ClipPath(clipPath string) (ref *TagSvgFeFlood)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgFeFlood) ClipRule 

func (e *TagSvgFeFlood) ClipRule(value interface{}) (ref *TagSvgFeFlood)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgFeFlood) Color 

func (e *TagSvgFeFlood) Color(value interface{}) (ref *TagSvgFeFlood)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgFeFlood) ColorInterpolation 

func (e *TagSvgFeFlood) ColorInterpolation(value interface{}) (ref *TagSvgFeFlood)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgFeFlood) ColorInterpolationFilters 

func (e *TagSvgFeFlood) ColorInterpolationFilters(value interface{}) (ref *TagSvgFeFlood)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgFeFlood) CreateElement 

func (e *TagSvgFeFlood) CreateElement() (ref *TagSvgFeFlood)

func (*TagSvgFeFlood) Cursor 

func (e *TagSvgFeFlood) Cursor(cursor SvgCursor) (ref *TagSvgFeFlood)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgFeFlood) Direction 

func (e *TagSvgFeFlood) Direction(direction SvgDirection) (ref *TagSvgFeFlood)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgFeFlood) Display 

func (e *TagSvgFeFlood) Display(value interface{}) (ref *TagSvgFeFlood)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgFeFlood) DominantBaseline 

func (e *TagSvgFeFlood) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgFeFlood)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgFeFlood) Fill 

func (e *TagSvgFeFlood) Fill(value interface{}) (ref *TagSvgFeFlood)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgFeFlood) FillOpacity 

func (e *TagSvgFeFlood) FillOpacity(value interface{}) (ref *TagSvgFeFlood)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgFeFlood) FillRule 

func (e *TagSvgFeFlood) FillRule(fillRule SvgFillRule) (ref *TagSvgFeFlood)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgFeFlood) Filter 

func (e *TagSvgFeFlood) Filter(filter string) (ref *TagSvgFeFlood)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgFeFlood) FloodColor 

func (e *TagSvgFeFlood) FloodColor(floodColor interface{}) (ref *TagSvgFeFlood)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgFeFlood) FloodOpacity 

func (e *TagSvgFeFlood) FloodOpacity(floodOpacity float64) (ref *TagSvgFeFlood)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgFeFlood) FontFamily 

func (e *TagSvgFeFlood) FontFamily(fontFamily string) (ref *TagSvgFeFlood)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgFeFlood) FontSize 

func (e *TagSvgFeFlood) FontSize(fontSize interface{}) (ref *TagSvgFeFlood)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgFeFlood) FontSizeAdjust 

func (e *TagSvgFeFlood) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgFeFlood)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgFeFlood) FontStretch 

func (e *TagSvgFeFlood) FontStretch(fontStretch interface{}) (ref *TagSvgFeFlood)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgFeFlood) FontStyle 

func (e *TagSvgFeFlood) FontStyle(fontStyle FontStyleRule) (ref *TagSvgFeFlood)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgFeFlood) FontVariant 

func (e *TagSvgFeFlood) FontVariant(value interface{}) (ref *TagSvgFeFlood)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgFeFlood) FontWeight 

func (e *TagSvgFeFlood) FontWeight(value interface{}) (ref *TagSvgFeFlood)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgFeFlood) Get 

func (e *TagSvgFeFlood) Get() (el js.Value)

func (*TagSvgFeFlood) Height 

func (e *TagSvgFeFlood) Height(height interface{}) (ref *TagSvgFeFlood)

Height

English: 

The height attribute defines the vertical length of an element in the user coordinate system.
     float32: 1.0 = "100%"
     any other type: interface{}

Português: 

O atributo height define o comprimento vertical de um elemento no sistema de coordenadas do usuário.
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

func (*TagSvgFeFlood) Html 

func (e *TagSvgFeFlood) Html(value string) (ref *TagSvgFeFlood)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgFeFlood) Id 

func (e *TagSvgFeFlood) Id(id string) (ref *TagSvgFeFlood)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgFeFlood) ImageRendering 

func (e *TagSvgFeFlood) ImageRendering(imageRendering string) (ref *TagSvgFeFlood)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgFeFlood) Init 

func (e *TagSvgFeFlood) Init() (ref *TagSvgFeFlood)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgFeFlood) Lang 

func (e *TagSvgFeFlood) Lang(value interface{}) (ref *TagSvgFeFlood)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgFeFlood) LetterSpacing 

func (e *TagSvgFeFlood) LetterSpacing(value float64) (ref *TagSvgFeFlood)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgFeFlood) LightingColor 

func (e *TagSvgFeFlood) LightingColor(value interface{}) (ref *TagSvgFeFlood)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgFeFlood) MarkerEnd 

func (e *TagSvgFeFlood) MarkerEnd(value interface{}) (ref *TagSvgFeFlood)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgFeFlood) MarkerMid 

func (e *TagSvgFeFlood) MarkerMid(value interface{}) (ref *TagSvgFeFlood)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgFeFlood) MarkerStart 

func (e *TagSvgFeFlood) MarkerStart(value interface{}) (ref *TagSvgFeFlood)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgFeFlood) Mask 

func (e *TagSvgFeFlood) Mask(value interface{}) (ref *TagSvgFeFlood)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgFeFlood) Opacity 

func (e *TagSvgFeFlood) Opacity(value interface{}) (ref *TagSvgFeFlood)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgFeFlood) Overflow 

func (e *TagSvgFeFlood) Overflow(value interface{}) (ref *TagSvgFeFlood)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgFeFlood) PointerEvents 

func (e *TagSvgFeFlood) PointerEvents(value interface{}) (ref *TagSvgFeFlood)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgFeFlood) Result 

func (e *TagSvgFeFlood) Result(value interface{}) (ref *TagSvgFeFlood)

Result

English:

The result attribute defines the assigned name for this filter primitive. If supplied, then graphics that result from processing this filter primitive can be referenced by an in attribute on a subsequent filter primitive within the same <filter> element. If no value is provided, the output will only be available for re-use as the implicit input into the next filter primitive if that filter primitive provides no value for its in attribute.

Português:

O atributo result define o nome atribuído para esta primitiva de filtro. Se fornecido, os gráficos resultantes do processamento dessa primitiva de filtro podem ser referenciados por um atributo in em uma primitiva de filtro subsequente dentro do mesmo elemento <filter>. Se nenhum valor for fornecido, a saída só estará disponível para reutilização como entrada implícita na próxima primitiva de filtro se essa primitiva de filtro não fornecer valor para seu atributo in.

func (*TagSvgFeFlood) ShapeRendering 

func (e *TagSvgFeFlood) ShapeRendering(value interface{}) (ref *TagSvgFeFlood)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgFeFlood) StopColor 

func (e *TagSvgFeFlood) StopColor(value interface{}) (ref *TagSvgFeFlood)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgFeFlood) StopOpacity 

func (e *TagSvgFeFlood) StopOpacity(value interface{}) (ref *TagSvgFeFlood)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgFeFlood) Stroke 

func (e *TagSvgFeFlood) Stroke(value interface{}) (ref *TagSvgFeFlood)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgFeFlood) StrokeDasharray 

func (e *TagSvgFeFlood) StrokeDasharray(value interface{}) (ref *TagSvgFeFlood)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgFeFlood) StrokeLineCap 

func (e *TagSvgFeFlood) StrokeLineCap(value interface{}) (ref *TagSvgFeFlood)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgFeFlood) StrokeLineJoin 

func (e *TagSvgFeFlood) StrokeLineJoin(value interface{}) (ref *TagSvgFeFlood)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgFeFlood) StrokeMiterLimit 

func (e *TagSvgFeFlood) StrokeMiterLimit(value float64) (ref *TagSvgFeFlood)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgFeFlood) StrokeOpacity 

func (e *TagSvgFeFlood) StrokeOpacity(value interface{}) (ref *TagSvgFeFlood)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgFeFlood) StrokeWidth 

func (e *TagSvgFeFlood) StrokeWidth(value interface{}) (ref *TagSvgFeFlood)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeFlood) Style 

func (e *TagSvgFeFlood) Style(value string) (ref *TagSvgFeFlood)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgFeFlood) Tabindex 

func (e *TagSvgFeFlood) Tabindex(value int) (ref *TagSvgFeFlood)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgFeFlood) Text 

func (e *TagSvgFeFlood) Text(value string) (ref *TagSvgFeFlood)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgFeFlood) TextAnchor 

func (e *TagSvgFeFlood) TextAnchor(value interface{}) (ref *TagSvgFeFlood)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgFeFlood) TextDecoration 

func (e *TagSvgFeFlood) TextDecoration(value interface{}) (ref *TagSvgFeFlood)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgFeFlood) TextRendering 

func (e *TagSvgFeFlood) TextRendering(value interface{}) (ref *TagSvgFeFlood)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgFeFlood) Transform 

func (e *TagSvgFeFlood) Transform(value interface{}) (ref *TagSvgFeFlood)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgFeFlood) UnicodeBidi 

func (e *TagSvgFeFlood) UnicodeBidi(value interface{}) (ref *TagSvgFeFlood)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgFeFlood) VectorEffect 

func (e *TagSvgFeFlood) VectorEffect(value interface{}) (ref *TagSvgFeFlood)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgFeFlood) Visibility 

func (e *TagSvgFeFlood) Visibility(value interface{}) (ref *TagSvgFeFlood)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgFeFlood) Width 

func (e *TagSvgFeFlood) Width(value interface{}) (ref *TagSvgFeFlood)

Width

English:

The width attribute defines the horizontal length of an element in the user coordinate system. 

Input:
  value: the horizontal length of an element
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo largura define o comprimento horizontal de um elemento no sistema de coordenadas do usuário. 

Entrada:
  value: o comprimento horizontal de um elemento
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeFlood) WordSpacing 

func (e *TagSvgFeFlood) WordSpacing(value interface{}) (ref *TagSvgFeFlood)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgFeFlood) WritingMode 

func (e *TagSvgFeFlood) WritingMode(value interface{}) (ref *TagSvgFeFlood)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgFeFlood) X 

func (e *TagSvgFeFlood) X(value interface{}) (ref *TagSvgFeFlood)

X

English:

The x attribute defines an x-axis coordinate in the user coordinate system. 

Input:
  value: defines an x-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo x define uma coordenada do eixo x no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo x
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgFeFlood) XmlLang 

func (e *TagSvgFeFlood) XmlLang(value interface{}) (ref *TagSvgFeFlood)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

func (*TagSvgFeFlood) Y 

func (e *TagSvgFeFlood) Y(value interface{}) (ref *TagSvgFeFlood)

Y

English:

The y attribute defines an y-axis coordinate in the user coordinate system. 

Input:
  value: defines an y-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo y define uma coordenada do eixo y no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo y
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

type TagSvgFeFuncA 

type TagSvgFeFuncA struct {
	// contains filtered or unexported fields
}

TagSvgFeFuncA

English:

The <feFuncA> SVG filter primitive defines the transfer function for the alpha component of the input graphic of its parent <feComponentTransfer> element.

Português:

A primitiva de filtro SVG <feFuncA> define a função de transferência para o componente alfa do gráfico de entrada de seu elemento pai <feComponentTransfer>.

func (*TagSvgFeFuncA) Amplitude 

func (e *TagSvgFeFuncA) Amplitude(value interface{}) (ref *TagSvgFeFuncA)

Amplitude

English: 

The amplitude attribute controls the amplitude of the gamma function of a component transfer element when its type
attribute is gamma.

 Input:
   value: controls the amplitude of the gamma function
     []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1) rgba(255,0,0,1)"
     []float32: []float64{0.0, 0.1} = "0% 10%"
     []float64: []float64{0.0, 10.0} = "0 10"
     []time.Duration: []time.Duration{0, time.Second} = "0s 1s"
     time.Duration: time.Second = "1s"
     float32: 0.1 = "10%"
     float64: 10.0 = "10"
     color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
     any other type: interface{}

Português: 

O atributo amplitude controla à amplitude da função gama de um elemento de transferência de componente quando seu
atributo de tipo é gama.

 Entrada:
   value: controla a amplitude da função de gama
     []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1) rgba(255,0,0,1)"
     []float32: []float64{0.0, 0.1} = "0% 10%"
     []float64: []float64{0.0, 10.0} = "0 10"
     []time.Duration: []time.Duration{0, time.Second} = "0s 1s"
     time.Duration: time.Second = "1s"
     float32: 0.1 = "10%"
     float64: 10.0 = "10"
     color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
     qualquer outro tipo: interface{}

func (*TagSvgFeFuncA) Append 

func (e *TagSvgFeFuncA) Append(elements ...Compatible) (ref *TagSvgFeFuncA)

func (*TagSvgFeFuncA) AppendById 

func (e *TagSvgFeFuncA) AppendById(appendId string) (ref *TagSvgFeFuncA)

func (*TagSvgFeFuncA) AppendToElement 

func (e *TagSvgFeFuncA) AppendToElement(el js.Value) (ref *TagSvgFeFuncA)

func (*TagSvgFeFuncA) AppendToStage 

func (e *TagSvgFeFuncA) AppendToStage() (ref *TagSvgFeFuncA)

func (*TagSvgFeFuncA) CreateElement 

func (e *TagSvgFeFuncA) CreateElement() (ref *TagSvgFeFuncA)

func (*TagSvgFeFuncA) Exponent 

func (e *TagSvgFeFuncA) Exponent(exponent float64) (ref *TagSvgFeFuncA)

Exponent

English: 

The exponent attribute defines the exponent of the gamma function.

Portuguese 

O atributo expoente define o expoente da função gama.

func (*TagSvgFeFuncA) Get 

func (e *TagSvgFeFuncA) Get() (el js.Value)

func (*TagSvgFeFuncA) Html 

func (e *TagSvgFeFuncA) Html(value string) (ref *TagSvgFeFuncA)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgFeFuncA) Id 

func (e *TagSvgFeFuncA) Id(id string) (ref *TagSvgFeFuncA)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgFeFuncA) Init 

func (e *TagSvgFeFuncA) Init() (ref *TagSvgFeFuncA)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgFeFuncA) Intercept 

func (e *TagSvgFeFuncA) Intercept(intercept float64) (ref *TagSvgFeFuncA)

Intercept

English: 

The intercept attribute defines the intercept of the linear function of color component transfers when the type
attribute is set to linear.

Portuguese 

O atributo de interceptação define a interceptação da função linear de transferências de componentes de cor quando
o atributo de tipo é definido como linear.

func (*TagSvgFeFuncA) Lang 

func (e *TagSvgFeFuncA) Lang(value interface{}) (ref *TagSvgFeFuncA)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgFeFuncA) Offset 

func (e *TagSvgFeFuncA) Offset(value interface{}) (ref *TagSvgFeFuncA)

Offset

English:

This attribute defines where the gradient stop is placed along the gradient vector.

Português:

Este atributo define onde a parada de gradiente é colocada ao longo do vetor de gradiente.

func (*TagSvgFeFuncA) Slope deprecated 

func (e *TagSvgFeFuncA) Slope(value interface{}) (ref *TagSvgFeFuncA)

Slope

English:

Deprecated: This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.

The slope attribute indicates the vertical stroke angle of a font.

Português:

Descontinuado: este recurso não é mais recomendado. Embora alguns navegadores ainda possam suportá-lo, ele pode já ter sido removido dos padrões da Web relevantes, pode estar em processo de eliminação ou pode ser mantido apenas para fins de compatibilidade. Evite usá-lo e atualize o código existente, se possível; consulte a tabela de compatibilidade na parte inferior desta página para orientar sua decisão. Esteja ciente de que esse recurso pode deixar de funcionar a qualquer momento.

O atributo slope indica o ângulo de traço vertical de uma fonte.

func (*TagSvgFeFuncA) Tabindex 

func (e *TagSvgFeFuncA) Tabindex(value int) (ref *TagSvgFeFuncA)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgFeFuncA) TableValues 

func (e *TagSvgFeFuncA) TableValues(value interface{}) (ref *TagSvgFeFuncA)

TableValues

English:

The tableValues attribute defines a list of numbers defining a lookup table of values for a color component transfer function. 

Input:
  value: defines a list of numbers
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1) rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0% 10%"
    []float64: []float64{0.0, 10.0} = "0 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    any other type: interface{}

Português:

O atributo tableValues define uma lista de números que definem uma tabela de consulta de valores para uma função de transferência de componente de cor. 

Entrada:
  value: define uma lista de números
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1) rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0% 10%"
    []float64: []float64{0.0, 10.0} = "0 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    qualquer outro tipo: interface{}

func (*TagSvgFeFuncA) Text 

func (e *TagSvgFeFuncA) Text(value string) (ref *TagSvgFeFuncA)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgFeFuncA) Type 

func (e *TagSvgFeFuncA) Type(value interface{}) (ref *TagSvgFeFuncA)

Type

English:

Indicates the type of component transfer function. 

Input:
  value: type of component transfer function
    const: KSvgTypeFeFunc... (e.g. KSvgTypeFeFuncIdentity)
    any other type: interface{}

Português:

Indica o tipo de função de transferência de componentes. 

Input:
  value: tipo de função de transferência de componente
    const: KSvgTypeFeFunc... (ex. KSvgTypeFeFuncIdentity)
    any other type: interface{}

func (*TagSvgFeFuncA) XmlLang 

func (e *TagSvgFeFuncA) XmlLang(value interface{}) (ref *TagSvgFeFuncA)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

type TagSvgFeFuncB 

type TagSvgFeFuncB struct {
	// contains filtered or unexported fields
}

TagSvgFeFuncB

English:

The <feFuncB> SVG filter primitive defines the transfer function for the blue component of the input graphic of its parent <feComponentTransfer> element.

Português:

The <feFuncB> SVG filter primitive defines the transfer function for the blue component of the input graphic of its parent <feComponentTransfer> element.

func (*TagSvgFeFuncB) Amplitude 

func (e *TagSvgFeFuncB) Amplitude(value interface{}) (ref *TagSvgFeFuncB)

Amplitude

English: 

The amplitude attribute controls the amplitude of the gamma function of a component transfer element when its type
attribute is gamma.

 Input:
   value: controls the amplitude of the gamma function
     []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1) rgba(255,0,0,1)"
     []float32: []float64{0.0, 0.1} = "0% 10%"
     []float64: []float64{0.0, 10.0} = "0 10"
     []time.Duration: []time.Duration{0, time.Second} = "0s 1s"
     time.Duration: time.Second = "1s"
     float32: 0.1 = "10%"
     float64: 10.0 = "10"
     color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
     any other type: interface{}

Português: 

O atributo amplitude controla à amplitude da função gama de um elemento de transferência de componente quando seu
atributo de tipo é gama.

 Entrada:
   value: controla a amplitude da função de gama
     []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1) rgba(255,0,0,1)"
     []float32: []float64{0.0, 0.1} = "0% 10%"
     []float64: []float64{0.0, 10.0} = "0 10"
     []time.Duration: []time.Duration{0, time.Second} = "0s 1s"
     time.Duration: time.Second = "1s"
     float32: 0.1 = "10%"
     float64: 10.0 = "10"
     color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
     qualquer outro tipo: interface{}

func (*TagSvgFeFuncB) Append 

func (e *TagSvgFeFuncB) Append(elements ...Compatible) (ref *TagSvgFeFuncB)

func (*TagSvgFeFuncB) AppendById 

func (e *TagSvgFeFuncB) AppendById(appendId string) (ref *TagSvgFeFuncB)

func (*TagSvgFeFuncB) AppendToElement 

func (e *TagSvgFeFuncB) AppendToElement(el js.Value) (ref *TagSvgFeFuncB)

func (*TagSvgFeFuncB) AppendToStage 

func (e *TagSvgFeFuncB) AppendToStage() (ref *TagSvgFeFuncB)

func (*TagSvgFeFuncB) CreateElement 

func (e *TagSvgFeFuncB) CreateElement() (ref *TagSvgFeFuncB)

func (*TagSvgFeFuncB) Exponent 

func (e *TagSvgFeFuncB) Exponent(exponent float64) (ref *TagSvgFeFuncB)

Exponent

English: 

The exponent attribute defines the exponent of the gamma function.

Portuguese 

O atributo expoente define o expoente da função gama.

func (*TagSvgFeFuncB) Get 

func (e *TagSvgFeFuncB) Get() (el js.Value)

func (*TagSvgFeFuncB) Html 

func (e *TagSvgFeFuncB) Html(value string) (ref *TagSvgFeFuncB)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgFeFuncB) Id 

func (e *TagSvgFeFuncB) Id(id string) (ref *TagSvgFeFuncB)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgFeFuncB) Init 

func (e *TagSvgFeFuncB) Init() (ref *TagSvgFeFuncB)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgFeFuncB) Intercept 

func (e *TagSvgFeFuncB) Intercept(intercept float64) (ref *TagSvgFeFuncB)

Intercept

English: 

The intercept attribute defines the intercept of the linear function of color component transfers when the type
attribute is set to linear.

Portuguese 

O atributo de interceptação define a interceptação da função linear de transferências de componentes de cor quando
o atributo de tipo é definido como linear.

func (*TagSvgFeFuncB) Lang 

func (e *TagSvgFeFuncB) Lang(value interface{}) (ref *TagSvgFeFuncB)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgFeFuncB) Offset 

func (e *TagSvgFeFuncB) Offset(value interface{}) (ref *TagSvgFeFuncB)

Offset

English:

This attribute defines where the gradient stop is placed along the gradient vector.

Português:

Este atributo define onde a parada de gradiente é colocada ao longo do vetor de gradiente.

func (*TagSvgFeFuncB) Slope deprecated 

func (e *TagSvgFeFuncB) Slope(value interface{}) (ref *TagSvgFeFuncB)

Slope

English:

Deprecated: This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.

The slope attribute indicates the vertical stroke angle of a font.

Português:

Descontinuado: este recurso não é mais recomendado. Embora alguns navegadores ainda possam suportá-lo, ele pode já ter sido removido dos padrões da Web relevantes, pode estar em processo de eliminação ou pode ser mantido apenas para fins de compatibilidade. Evite usá-lo e atualize o código existente, se possível; consulte a tabela de compatibilidade na parte inferior desta página para orientar sua decisão. Esteja ciente de que esse recurso pode deixar de funcionar a qualquer momento.

O atributo slope indica o ângulo de traço vertical de uma fonte.

func (*TagSvgFeFuncB) Tabindex 

func (e *TagSvgFeFuncB) Tabindex(value int) (ref *TagSvgFeFuncB)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgFeFuncB) TableValues 

func (e *TagSvgFeFuncB) TableValues(value interface{}) (ref *TagSvgFeFuncB)

TableValues

English:

The tableValues attribute defines a list of numbers defining a lookup table of values for a color component transfer function. 

Input:
  value: defines a list of numbers
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1) rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0% 10%"
    []float64: []float64{0.0, 10.0} = "0 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    any other type: interface{}

Português:

O atributo tableValues define uma lista de números que definem uma tabela de consulta de valores para uma função de transferência de componente de cor. 

Entrada:
  value: define uma lista de números
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1) rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0% 10%"
    []float64: []float64{0.0, 10.0} = "0 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    qualquer outro tipo: interface{}

func (*TagSvgFeFuncB) Text 

func (e *TagSvgFeFuncB) Text(value string) (ref *TagSvgFeFuncB)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgFeFuncB) Type 

func (e *TagSvgFeFuncB) Type(value interface{}) (ref *TagSvgFeFuncB)

Type

English:

Indicates the type of component transfer function. 

Input:
  value: type of component transfer function
    const: KSvgTypeFeFunc... (e.g. KSvgTypeFeFuncIdentity)
    any other type: interface{}

Português:

Indica o tipo de função de transferência de componentes. 

Input:
  value: tipo de função de transferência de componente
    const: KSvgTypeFeFunc... (ex. KSvgTypeFeFuncIdentity)
    any other type: interface{}

func (*TagSvgFeFuncB) XmlLang 

func (e *TagSvgFeFuncB) XmlLang(value interface{}) (ref *TagSvgFeFuncB)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

type TagSvgFeFuncG 

type TagSvgFeFuncG struct {
	// contains filtered or unexported fields
}

TagSvgFeFuncG

English:

The <feFuncG> SVG filter primitive defines the transfer function for the green component of the input graphic of its parent <feComponentTransfer> element.

Português:

A primitiva de filtro SVG <feFuncG> define a função de transferência para o componente verde do gráfico de entrada de seu elemento pai <feComponentTransfer>.

func (*TagSvgFeFuncG) Amplitude 

func (e *TagSvgFeFuncG) Amplitude(value interface{}) (ref *TagSvgFeFuncG)

Amplitude

English: 

The amplitude attribute controls the amplitude of the gamma function of a component transfer element when its type
attribute is gamma.

 Input:
   value: controls the amplitude of the gamma function
     []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1) rgba(255,0,0,1)"
     []float32: []float64{0.0, 0.1} = "0% 10%"
     []float64: []float64{0.0, 10.0} = "0 10"
     []time.Duration: []time.Duration{0, time.Second} = "0s 1s"
     time.Duration: time.Second = "1s"
     float32: 0.1 = "10%"
     float64: 10.0 = "10"
     color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
     any other type: interface{}

Português: 

O atributo amplitude controla à amplitude da função gama de um elemento de transferência de componente quando seu
atributo de tipo é gama.

 Entrada:
   value: controla a amplitude da função de gama
     []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1) rgba(255,0,0,1)"
     []float32: []float64{0.0, 0.1} = "0% 10%"
     []float64: []float64{0.0, 10.0} = "0 10"
     []time.Duration: []time.Duration{0, time.Second} = "0s 1s"
     time.Duration: time.Second = "1s"
     float32: 0.1 = "10%"
     float64: 10.0 = "10"
     color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
     qualquer outro tipo: interface{}

func (*TagSvgFeFuncG) Append 

func (e *TagSvgFeFuncG) Append(elements ...Compatible) (ref *TagSvgFeFuncG)

func (*TagSvgFeFuncG) AppendById 

func (e *TagSvgFeFuncG) AppendById(appendId string) (ref *TagSvgFeFuncG)

func (*TagSvgFeFuncG) AppendToElement 

func (e *TagSvgFeFuncG) AppendToElement(el js.Value) (ref *TagSvgFeFuncG)

func (*TagSvgFeFuncG) AppendToStage 

func (e *TagSvgFeFuncG) AppendToStage() (ref *TagSvgFeFuncG)

func (*TagSvgFeFuncG) CreateElement 

func (e *TagSvgFeFuncG) CreateElement() (ref *TagSvgFeFuncG)

func (*TagSvgFeFuncG) Exponent 

func (e *TagSvgFeFuncG) Exponent(exponent float64) (ref *TagSvgFeFuncG)

Exponent

English: 

The exponent attribute defines the exponent of the gamma function.

Portuguese 

O atributo expoente define o expoente da função gama.

func (*TagSvgFeFuncG) Get 

func (e *TagSvgFeFuncG) Get() (el js.Value)

func (*TagSvgFeFuncG) Html 

func (e *TagSvgFeFuncG) Html(value string) (ref *TagSvgFeFuncG)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgFeFuncG) Id 

func (e *TagSvgFeFuncG) Id(id string) (ref *TagSvgFeFuncG)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgFeFuncG) Init 

func (e *TagSvgFeFuncG) Init() (ref *TagSvgFeFuncG)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgFeFuncG) Intercept 

func (e *TagSvgFeFuncG) Intercept(intercept float64) (ref *TagSvgFeFuncG)

Intercept

English: 

The intercept attribute defines the intercept of the linear function of color component transfers when the type
attribute is set to linear.

Portuguese 

O atributo de interceptação define a interceptação da função linear de transferências de componentes de cor quando
o atributo de tipo é definido como linear.

func (*TagSvgFeFuncG) Lang 

func (e *TagSvgFeFuncG) Lang(value interface{}) (ref *TagSvgFeFuncG)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgFeFuncG) Offset 

func (e *TagSvgFeFuncG) Offset(value interface{}) (ref *TagSvgFeFuncG)

Offset

English:

This attribute defines where the gradient stop is placed along the gradient vector.

Português:

Este atributo define onde a parada de gradiente é colocada ao longo do vetor de gradiente.

func (*TagSvgFeFuncG) Slope deprecated 

func (e *TagSvgFeFuncG) Slope(value interface{}) (ref *TagSvgFeFuncG)

Slope

English:

Deprecated: This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.

The slope attribute indicates the vertical stroke angle of a font.

Português:

Descontinuado: este recurso não é mais recomendado. Embora alguns navegadores ainda possam suportá-lo, ele pode já ter sido removido dos padrões da Web relevantes, pode estar em processo de eliminação ou pode ser mantido apenas para fins de compatibilidade. Evite usá-lo e atualize o código existente, se possível; consulte a tabela de compatibilidade na parte inferior desta página para orientar sua decisão. Esteja ciente de que esse recurso pode deixar de funcionar a qualquer momento.

O atributo slope indica o ângulo de traço vertical de uma fonte.

func (*TagSvgFeFuncG) Tabindex 

func (e *TagSvgFeFuncG) Tabindex(value int) (ref *TagSvgFeFuncG)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgFeFuncG) TableValues 

func (e *TagSvgFeFuncG) TableValues(value interface{}) (ref *TagSvgFeFuncG)

TableValues

English:

The tableValues attribute defines a list of numbers defining a lookup table of values for a color component transfer function. 

Input:
  value: defines a list of numbers
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1) rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0% 10%"
    []float64: []float64{0.0, 10.0} = "0 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    any other type: interface{}

Português:

O atributo tableValues define uma lista de números que definem uma tabela de consulta de valores para uma função de transferência de componente de cor. 

Entrada:
  value: define uma lista de números
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1) rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0% 10%"
    []float64: []float64{0.0, 10.0} = "0 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    qualquer outro tipo: interface{}

func (*TagSvgFeFuncG) Text 

func (e *TagSvgFeFuncG) Text(value string) (ref *TagSvgFeFuncG)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgFeFuncG) Type 

func (e *TagSvgFeFuncG) Type(value interface{}) (ref *TagSvgFeFuncG)

Type

English:

Indicates the type of component transfer function. 

Input:
  value: type of component transfer function
    const: KSvgTypeFeFunc... (e.g. KSvgTypeFeFuncIdentity)
    any other type: interface{}

Português:

Indica o tipo de função de transferência de componentes. 

Input:
  value: tipo de função de transferência de componente
    const: KSvgTypeFeFunc... (ex. KSvgTypeFeFuncIdentity)
    any other type: interface{}

func (*TagSvgFeFuncG) XmlLang 

func (e *TagSvgFeFuncG) XmlLang(value interface{}) (ref *TagSvgFeFuncG)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

type TagSvgFeFuncR 

type TagSvgFeFuncR struct {
	// contains filtered or unexported fields
}

TagSvgFeFuncR

English:

The <feFuncR> SVG filter primitive defines the transfer function for the red component of the input graphic of its parent <feComponentTransfer> element.

Português:

A primitiva de filtro SVG <feFuncR> define a função de transferência para o componente vermelho do gráfico de entrada de seu elemento pai <feComponentTransfer>.

func (*TagSvgFeFuncR) Amplitude 

func (e *TagSvgFeFuncR) Amplitude(value interface{}) (ref *TagSvgFeFuncR)

Amplitude

English: 

The amplitude attribute controls the amplitude of the gamma function of a component transfer element when its type
attribute is gamma.

 Input:
   value: controls the amplitude of the gamma function
     []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1) rgba(255,0,0,1)"
     []float32: []float64{0.0, 0.1} = "0% 10%"
     []float64: []float64{0.0, 10.0} = "0 10"
     []time.Duration: []time.Duration{0, time.Second} = "0s 1s"
     time.Duration: time.Second = "1s"
     float32: 0.1 = "10%"
     float64: 10.0 = "10"
     color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
     any other type: interface{}

Português: 

O atributo amplitude controla à amplitude da função gama de um elemento de transferência de componente quando seu
atributo de tipo é gama.

 Entrada:
   value: controla a amplitude da função de gama
     []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1) rgba(255,0,0,1)"
     []float32: []float64{0.0, 0.1} = "0% 10%"
     []float64: []float64{0.0, 10.0} = "0 10"
     []time.Duration: []time.Duration{0, time.Second} = "0s 1s"
     time.Duration: time.Second = "1s"
     float32: 0.1 = "10%"
     float64: 10.0 = "10"
     color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
     qualquer outro tipo: interface{}

func (*TagSvgFeFuncR) Append 

func (e *TagSvgFeFuncR) Append(elements ...Compatible) (ref *TagSvgFeFuncR)

func (*TagSvgFeFuncR) AppendById 

func (e *TagSvgFeFuncR) AppendById(appendId string) (ref *TagSvgFeFuncR)

func (*TagSvgFeFuncR) AppendToElement 

func (e *TagSvgFeFuncR) AppendToElement(el js.Value) (ref *TagSvgFeFuncR)

func (*TagSvgFeFuncR) AppendToStage 

func (e *TagSvgFeFuncR) AppendToStage() (ref *TagSvgFeFuncR)

func (*TagSvgFeFuncR) CreateElement 

func (e *TagSvgFeFuncR) CreateElement() (ref *TagSvgFeFuncR)

func (*TagSvgFeFuncR) Exponent 

func (e *TagSvgFeFuncR) Exponent(exponent float64) (ref *TagSvgFeFuncR)

Exponent

English: 

The exponent attribute defines the exponent of the gamma function.

Portuguese 

O atributo expoente define o expoente da função gama.

func (*TagSvgFeFuncR) Get 

func (e *TagSvgFeFuncR) Get() (el js.Value)

func (*TagSvgFeFuncR) Html 

func (e *TagSvgFeFuncR) Html(value string) (ref *TagSvgFeFuncR)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgFeFuncR) Id 

func (e *TagSvgFeFuncR) Id(id string) (ref *TagSvgFeFuncR)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgFeFuncR) Init 

func (e *TagSvgFeFuncR) Init() (ref *TagSvgFeFuncR)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgFeFuncR) Intercept 

func (e *TagSvgFeFuncR) Intercept(intercept float64) (ref *TagSvgFeFuncR)

Intercept

English: 

The intercept attribute defines the intercept of the linear function of color component transfers when the type
attribute is set to linear.

Portuguese 

O atributo de interceptação define a interceptação da função linear de transferências de componentes de cor quando
o atributo de tipo é definido como linear.

func (*TagSvgFeFuncR) Lang 

func (e *TagSvgFeFuncR) Lang(value interface{}) (ref *TagSvgFeFuncR)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgFeFuncR) Offset 

func (e *TagSvgFeFuncR) Offset(value interface{}) (ref *TagSvgFeFuncR)

Offset

English:

This attribute defines where the gradient stop is placed along the gradient vector.

Português:

Este atributo define onde a parada de gradiente é colocada ao longo do vetor de gradiente.

func (*TagSvgFeFuncR) Slope deprecated 

func (e *TagSvgFeFuncR) Slope(value interface{}) (ref *TagSvgFeFuncR)

Slope

English:

Deprecated: This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.

The slope attribute indicates the vertical stroke angle of a font.

Português:

Descontinuado: este recurso não é mais recomendado. Embora alguns navegadores ainda possam suportá-lo, ele pode já ter sido removido dos padrões da Web relevantes, pode estar em processo de eliminação ou pode ser mantido apenas para fins de compatibilidade. Evite usá-lo e atualize o código existente, se possível; consulte a tabela de compatibilidade na parte inferior desta página para orientar sua decisão. Esteja ciente de que esse recurso pode deixar de funcionar a qualquer momento.

O atributo slope indica o ângulo de traço vertical de uma fonte.

func (*TagSvgFeFuncR) Tabindex 

func (e *TagSvgFeFuncR) Tabindex(value int) (ref *TagSvgFeFuncR)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgFeFuncR) TableValues 

func (e *TagSvgFeFuncR) TableValues(value interface{}) (ref *TagSvgFeFuncR)

TableValues

English:

The tableValues attribute defines a list of numbers defining a lookup table of values for a color component transfer function. 

Input:
  value: defines a list of numbers
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1) rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0% 10%"
    []float64: []float64{0.0, 10.0} = "0 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    any other type: interface{}

Português:

O atributo tableValues define uma lista de números que definem uma tabela de consulta de valores para uma função de transferência de componente de cor. 

Entrada:
  value: define uma lista de números
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1) rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0% 10%"
    []float64: []float64{0.0, 10.0} = "0 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    qualquer outro tipo: interface{}

func (*TagSvgFeFuncR) Text 

func (e *TagSvgFeFuncR) Text(value string) (ref *TagSvgFeFuncR)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgFeFuncR) Type 

func (e *TagSvgFeFuncR) Type(value interface{}) (ref *TagSvgFeFuncR)

Type

English:

Indicates the type of component transfer function. 

Input:
  value: type of component transfer function
    const: KSvgTypeFeFunc... (e.g. KSvgTypeFeFuncIdentity)
    any other type: interface{}

Português:

Indica o tipo de função de transferência de componentes. 

Input:
  value: tipo de função de transferência de componente
    const: KSvgTypeFeFunc... (ex. KSvgTypeFeFuncIdentity)
    any other type: interface{}

func (*TagSvgFeFuncR) XmlLang 

func (e *TagSvgFeFuncR) XmlLang(value interface{}) (ref *TagSvgFeFuncR)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

type TagSvgFeGaussianBlur 

type TagSvgFeGaussianBlur struct {
	// contains filtered or unexported fields
}

TagSvgFeGaussianBlur

English:

The <feGaussianBlur> SVG filter primitive blurs the input image by the amount specified in stdDeviation, which defines the bell-curve.

Português:

A primitiva de filtro SVG <feGaussianBlur> desfoca a imagem de entrada pela quantidade especificada em stdDeviation, que define a curva de sino.

func (*TagSvgFeGaussianBlur) Append 

func (e *TagSvgFeGaussianBlur) Append(elements ...Compatible) (ref *TagSvgFeGaussianBlur)

func (*TagSvgFeGaussianBlur) AppendById 

func (e *TagSvgFeGaussianBlur) AppendById(appendId string) (ref *TagSvgFeGaussianBlur)

func (*TagSvgFeGaussianBlur) AppendToElement 

func (e *TagSvgFeGaussianBlur) AppendToElement(el js.Value) (ref *TagSvgFeGaussianBlur)

func (*TagSvgFeGaussianBlur) AppendToStage 

func (e *TagSvgFeGaussianBlur) AppendToStage() (ref *TagSvgFeGaussianBlur)

func (*TagSvgFeGaussianBlur) BaselineShift 

func (e *TagSvgFeGaussianBlur) BaselineShift(baselineShift interface{}) (ref *TagSvgFeGaussianBlur)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgFeGaussianBlur) Class 

func (e *TagSvgFeGaussianBlur) Class(class string) (ref *TagSvgFeGaussianBlur)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgFeGaussianBlur) ClipPath 

func (e *TagSvgFeGaussianBlur) ClipPath(clipPath string) (ref *TagSvgFeGaussianBlur)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgFeGaussianBlur) ClipRule 

func (e *TagSvgFeGaussianBlur) ClipRule(value interface{}) (ref *TagSvgFeGaussianBlur)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgFeGaussianBlur) Color 

func (e *TagSvgFeGaussianBlur) Color(value interface{}) (ref *TagSvgFeGaussianBlur)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgFeGaussianBlur) ColorInterpolation 

func (e *TagSvgFeGaussianBlur) ColorInterpolation(value interface{}) (ref *TagSvgFeGaussianBlur)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgFeGaussianBlur) ColorInterpolationFilters 

func (e *TagSvgFeGaussianBlur) ColorInterpolationFilters(value interface{}) (ref *TagSvgFeGaussianBlur)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgFeGaussianBlur) CreateElement 

func (e *TagSvgFeGaussianBlur) CreateElement() (ref *TagSvgFeGaussianBlur)

func (*TagSvgFeGaussianBlur) Cursor 

func (e *TagSvgFeGaussianBlur) Cursor(cursor SvgCursor) (ref *TagSvgFeGaussianBlur)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgFeGaussianBlur) Direction 

func (e *TagSvgFeGaussianBlur) Direction(direction SvgDirection) (ref *TagSvgFeGaussianBlur)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgFeGaussianBlur) Display 

func (e *TagSvgFeGaussianBlur) Display(value interface{}) (ref *TagSvgFeGaussianBlur)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgFeGaussianBlur) DominantBaseline 

func (e *TagSvgFeGaussianBlur) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgFeGaussianBlur)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgFeGaussianBlur) EdgeMode 

func (e *TagSvgFeGaussianBlur) EdgeMode(edgeMode SvgEdgeMode) (ref *TagSvgFeGaussianBlur)

EdgeMode

English: 

The edgeMode attribute determines how to extend the input image as necessary with color values so that the matrix
operations can be applied when the kernel is positioned at or near the edge of the input image.

Portuguese 

O atributo edgeMode determina como estender a imagem de entrada conforme necessário com valores de cor para que as
operações de matriz possam ser aplicadas quando o kernel estiver posicionado na borda da imagem de entrada ou
próximo a ela.

func (*TagSvgFeGaussianBlur) Fill 

func (e *TagSvgFeGaussianBlur) Fill(value interface{}) (ref *TagSvgFeGaussianBlur)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgFeGaussianBlur) FillOpacity 

func (e *TagSvgFeGaussianBlur) FillOpacity(value interface{}) (ref *TagSvgFeGaussianBlur)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgFeGaussianBlur) FillRule 

func (e *TagSvgFeGaussianBlur) FillRule(fillRule SvgFillRule) (ref *TagSvgFeGaussianBlur)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgFeGaussianBlur) Filter 

func (e *TagSvgFeGaussianBlur) Filter(filter string) (ref *TagSvgFeGaussianBlur)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgFeGaussianBlur) FloodColor 

func (e *TagSvgFeGaussianBlur) FloodColor(floodColor interface{}) (ref *TagSvgFeGaussianBlur)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgFeGaussianBlur) FloodOpacity 

func (e *TagSvgFeGaussianBlur) FloodOpacity(floodOpacity float64) (ref *TagSvgFeGaussianBlur)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgFeGaussianBlur) FontFamily 

func (e *TagSvgFeGaussianBlur) FontFamily(fontFamily string) (ref *TagSvgFeGaussianBlur)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgFeGaussianBlur) FontSize 

func (e *TagSvgFeGaussianBlur) FontSize(fontSize interface{}) (ref *TagSvgFeGaussianBlur)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgFeGaussianBlur) FontSizeAdjust 

func (e *TagSvgFeGaussianBlur) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgFeGaussianBlur)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgFeGaussianBlur) FontStretch 

func (e *TagSvgFeGaussianBlur) FontStretch(fontStretch interface{}) (ref *TagSvgFeGaussianBlur)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgFeGaussianBlur) FontStyle 

func (e *TagSvgFeGaussianBlur) FontStyle(fontStyle FontStyleRule) (ref *TagSvgFeGaussianBlur)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgFeGaussianBlur) FontVariant 

func (e *TagSvgFeGaussianBlur) FontVariant(value interface{}) (ref *TagSvgFeGaussianBlur)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgFeGaussianBlur) FontWeight 

func (e *TagSvgFeGaussianBlur) FontWeight(value interface{}) (ref *TagSvgFeGaussianBlur)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgFeGaussianBlur) Get 

func (e *TagSvgFeGaussianBlur) Get() (el js.Value)

func (*TagSvgFeGaussianBlur) Height 

func (e *TagSvgFeGaussianBlur) Height(height interface{}) (ref *TagSvgFeGaussianBlur)

Height

English: 

The height attribute defines the vertical length of an element in the user coordinate system.
     float32: 1.0 = "100%"
     any other type: interface{}

Português: 

O atributo height define o comprimento vertical de um elemento no sistema de coordenadas do usuário.
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

func (*TagSvgFeGaussianBlur) Html 

func (e *TagSvgFeGaussianBlur) Html(value string) (ref *TagSvgFeGaussianBlur)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgFeGaussianBlur) Id 

func (e *TagSvgFeGaussianBlur) Id(id string) (ref *TagSvgFeGaussianBlur)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgFeGaussianBlur) ImageRendering 

func (e *TagSvgFeGaussianBlur) ImageRendering(imageRendering string) (ref *TagSvgFeGaussianBlur)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgFeGaussianBlur) In 

func (e *TagSvgFeGaussianBlur) In(in interface{}) (ref *TagSvgFeGaussianBlur)

In

English: 

The in attribute identifies input for the given filter primitive.

 Input:
   in: identifies input for the given filter primitive.
     KSvgIn... (e.g. KSvgInSourceAlpha)
     any other type: interface{}

The value can be either one of the six keywords defined below, or a string which matches a previous result attribute value within the same <filter> element. If no value is provided and this is the first filter primitive, then this filter primitive will use SourceGraphic as its input. If no value is provided and this is a subsequent filter primitive, then this filter primitive will use the result from the previous filter primitive as its input.

If the value for result appears multiple times within a given <filter> element, then a reference to that result will use the closest preceding filter primitive with the given value for attribute result.

Portuguese 

O atributo in identifica à entrada para a primitiva de filtro fornecida.

 Entrada:
   in: identifica à entrada para a primitiva de filtro fornecida.
     KSvgIn... (e.g. KSvgInSourceAlpha)
     qualquer outro tipo: interface{}

O valor pode ser uma das seis palavras-chave definidas abaixo ou uma string que corresponda a um valor de atributo de resultado anterior dentro do mesmo elemento <filter>. Se nenhum valor for fornecido e esta for a primeira primitiva de filtro, essa primitiva de filtro usará SourceGraphic como sua entrada. Se nenhum valor for fornecido e esta for uma primitiva de filtro subsequente, essa primitiva de filtro usará o resultado da primitiva de filtro anterior como sua entrada.

Se o valor do resultado aparecer várias vezes em um determinado elemento <filter>, uma referência à esse resultado usará a primitiva de filtro anterior mais próxima com o valor fornecido para o resultado do atributo.

func (*TagSvgFeGaussianBlur) Init 

func (e *TagSvgFeGaussianBlur) Init() (ref *TagSvgFeGaussianBlur)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgFeGaussianBlur) Lang 

func (e *TagSvgFeGaussianBlur) Lang(value interface{}) (ref *TagSvgFeGaussianBlur)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgFeGaussianBlur) LetterSpacing 

func (e *TagSvgFeGaussianBlur) LetterSpacing(value float64) (ref *TagSvgFeGaussianBlur)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgFeGaussianBlur) LightingColor 

func (e *TagSvgFeGaussianBlur) LightingColor(value interface{}) (ref *TagSvgFeGaussianBlur)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgFeGaussianBlur) MarkerEnd 

func (e *TagSvgFeGaussianBlur) MarkerEnd(value interface{}) (ref *TagSvgFeGaussianBlur)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgFeGaussianBlur) MarkerMid 

func (e *TagSvgFeGaussianBlur) MarkerMid(value interface{}) (ref *TagSvgFeGaussianBlur)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgFeGaussianBlur) MarkerStart 

func (e *TagSvgFeGaussianBlur) MarkerStart(value interface{}) (ref *TagSvgFeGaussianBlur)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgFeGaussianBlur) Mask 

func (e *TagSvgFeGaussianBlur) Mask(value interface{}) (ref *TagSvgFeGaussianBlur)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgFeGaussianBlur) Opacity 

func (e *TagSvgFeGaussianBlur) Opacity(value interface{}) (ref *TagSvgFeGaussianBlur)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgFeGaussianBlur) Overflow 

func (e *TagSvgFeGaussianBlur) Overflow(value interface{}) (ref *TagSvgFeGaussianBlur)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgFeGaussianBlur) PointerEvents 

func (e *TagSvgFeGaussianBlur) PointerEvents(value interface{}) (ref *TagSvgFeGaussianBlur)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgFeGaussianBlur) Result 

func (e *TagSvgFeGaussianBlur) Result(value interface{}) (ref *TagSvgFeGaussianBlur)

Result

English:

The result attribute defines the assigned name for this filter primitive. If supplied, then graphics that result from processing this filter primitive can be referenced by an in attribute on a subsequent filter primitive within the same <filter> element. If no value is provided, the output will only be available for re-use as the implicit input into the next filter primitive if that filter primitive provides no value for its in attribute.

Português:

O atributo result define o nome atribuído para esta primitiva de filtro. Se fornecido, os gráficos resultantes do processamento dessa primitiva de filtro podem ser referenciados por um atributo in em uma primitiva de filtro subsequente dentro do mesmo elemento <filter>. Se nenhum valor for fornecido, a saída só estará disponível para reutilização como entrada implícita na próxima primitiva de filtro se essa primitiva de filtro não fornecer valor para seu atributo in.

func (*TagSvgFeGaussianBlur) ShapeRendering 

func (e *TagSvgFeGaussianBlur) ShapeRendering(value interface{}) (ref *TagSvgFeGaussianBlur)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgFeGaussianBlur) StdDeviation 

func (e *TagSvgFeGaussianBlur) StdDeviation(value interface{}) (ref *TagSvgFeGaussianBlur)

StdDeviation

English:

The stdDeviation attribute defines the standard deviation for the blur operation. 

Input:
  value: defines the standard deviation
    []float64: []float64{2,5} = "2 5"
    any other type: interface{}

Português:

O atributo stdDeviation define o desvio padrão para a operação de desfoque. 

Input:
  value: define o desvio padrão
    []float64: []float64{2,5} = "2 5"
    qualquer outro tipo: interface{}

func (*TagSvgFeGaussianBlur) StopColor 

func (e *TagSvgFeGaussianBlur) StopColor(value interface{}) (ref *TagSvgFeGaussianBlur)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgFeGaussianBlur) StopOpacity 

func (e *TagSvgFeGaussianBlur) StopOpacity(value interface{}) (ref *TagSvgFeGaussianBlur)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgFeGaussianBlur) Stroke 

func (e *TagSvgFeGaussianBlur) Stroke(value interface{}) (ref *TagSvgFeGaussianBlur)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgFeGaussianBlur) StrokeDasharray 

func (e *TagSvgFeGaussianBlur) StrokeDasharray(value interface{}) (ref *TagSvgFeGaussianBlur)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgFeGaussianBlur) StrokeLineCap 

func (e *TagSvgFeGaussianBlur) StrokeLineCap(value interface{}) (ref *TagSvgFeGaussianBlur)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgFeGaussianBlur) StrokeLineJoin 

func (e *TagSvgFeGaussianBlur) StrokeLineJoin(value interface{}) (ref *TagSvgFeGaussianBlur)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgFeGaussianBlur) StrokeMiterLimit 

func (e *TagSvgFeGaussianBlur) StrokeMiterLimit(value float64) (ref *TagSvgFeGaussianBlur)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgFeGaussianBlur) StrokeOpacity 

func (e *TagSvgFeGaussianBlur) StrokeOpacity(value interface{}) (ref *TagSvgFeGaussianBlur)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgFeGaussianBlur) StrokeWidth 

func (e *TagSvgFeGaussianBlur) StrokeWidth(value interface{}) (ref *TagSvgFeGaussianBlur)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeGaussianBlur) Style 

func (e *TagSvgFeGaussianBlur) Style(value string) (ref *TagSvgFeGaussianBlur)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgFeGaussianBlur) Tabindex 

func (e *TagSvgFeGaussianBlur) Tabindex(value int) (ref *TagSvgFeGaussianBlur)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgFeGaussianBlur) Text 

func (e *TagSvgFeGaussianBlur) Text(value string) (ref *TagSvgFeGaussianBlur)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgFeGaussianBlur) TextAnchor 

func (e *TagSvgFeGaussianBlur) TextAnchor(value interface{}) (ref *TagSvgFeGaussianBlur)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgFeGaussianBlur) TextDecoration 

func (e *TagSvgFeGaussianBlur) TextDecoration(value interface{}) (ref *TagSvgFeGaussianBlur)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgFeGaussianBlur) TextRendering 

func (e *TagSvgFeGaussianBlur) TextRendering(value interface{}) (ref *TagSvgFeGaussianBlur)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgFeGaussianBlur) Transform 

func (e *TagSvgFeGaussianBlur) Transform(value interface{}) (ref *TagSvgFeGaussianBlur)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgFeGaussianBlur) UnicodeBidi 

func (e *TagSvgFeGaussianBlur) UnicodeBidi(value interface{}) (ref *TagSvgFeGaussianBlur)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgFeGaussianBlur) VectorEffect 

func (e *TagSvgFeGaussianBlur) VectorEffect(value interface{}) (ref *TagSvgFeGaussianBlur)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgFeGaussianBlur) Visibility 

func (e *TagSvgFeGaussianBlur) Visibility(value interface{}) (ref *TagSvgFeGaussianBlur)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgFeGaussianBlur) Width 

func (e *TagSvgFeGaussianBlur) Width(value interface{}) (ref *TagSvgFeGaussianBlur)

Width

English:

The width attribute defines the horizontal length of an element in the user coordinate system. 

Input:
  value: the horizontal length of an element
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo largura define o comprimento horizontal de um elemento no sistema de coordenadas do usuário. 

Entrada:
  value: o comprimento horizontal de um elemento
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeGaussianBlur) WordSpacing 

func (e *TagSvgFeGaussianBlur) WordSpacing(value interface{}) (ref *TagSvgFeGaussianBlur)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgFeGaussianBlur) WritingMode 

func (e *TagSvgFeGaussianBlur) WritingMode(value interface{}) (ref *TagSvgFeGaussianBlur)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgFeGaussianBlur) X 

func (e *TagSvgFeGaussianBlur) X(value interface{}) (ref *TagSvgFeGaussianBlur)

X

English:

The x attribute defines an x-axis coordinate in the user coordinate system. 

Input:
  value: defines an x-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo x define uma coordenada do eixo x no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo x
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgFeGaussianBlur) XmlLang 

func (e *TagSvgFeGaussianBlur) XmlLang(value interface{}) (ref *TagSvgFeGaussianBlur)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

func (*TagSvgFeGaussianBlur) Y 

func (e *TagSvgFeGaussianBlur) Y(value interface{}) (ref *TagSvgFeGaussianBlur)

Y

English:

The y attribute defines an y-axis coordinate in the user coordinate system. 

Input:
  value: defines an y-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo y define uma coordenada do eixo y no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo y
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

type TagSvgFeImage 

type TagSvgFeImage struct {
	// contains filtered or unexported fields
}

TagSvgFeImage

English:

The <feImage> SVG filter primitive fetches image data from an external source and provides the pixel data as output (meaning if the external source is an SVG image, it is rasterized.)

Português:

A primitiva de filtro SVG <feImage> busca dados de imagem de uma fonte externa e fornece os dados de pixel como saída (ou seja, se a fonte externa for uma imagem SVG, ela será rasterizada).

func (*TagSvgFeImage) Append 

func (e *TagSvgFeImage) Append(elements ...Compatible) (ref *TagSvgFeImage)

func (*TagSvgFeImage) AppendById 

func (e *TagSvgFeImage) AppendById(appendId string) (ref *TagSvgFeImage)

func (*TagSvgFeImage) AppendToElement 

func (e *TagSvgFeImage) AppendToElement(el js.Value) (ref *TagSvgFeImage)

func (*TagSvgFeImage) AppendToStage 

func (e *TagSvgFeImage) AppendToStage() (ref *TagSvgFeImage)

func (*TagSvgFeImage) BaselineShift 

func (e *TagSvgFeImage) BaselineShift(baselineShift interface{}) (ref *TagSvgFeImage)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgFeImage) Class 

func (e *TagSvgFeImage) Class(class string) (ref *TagSvgFeImage)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgFeImage) ClipPath 

func (e *TagSvgFeImage) ClipPath(clipPath string) (ref *TagSvgFeImage)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgFeImage) ClipRule 

func (e *TagSvgFeImage) ClipRule(value interface{}) (ref *TagSvgFeImage)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgFeImage) Color 

func (e *TagSvgFeImage) Color(value interface{}) (ref *TagSvgFeImage)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgFeImage) ColorInterpolation 

func (e *TagSvgFeImage) ColorInterpolation(value interface{}) (ref *TagSvgFeImage)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgFeImage) ColorInterpolationFilters 

func (e *TagSvgFeImage) ColorInterpolationFilters(value interface{}) (ref *TagSvgFeImage)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgFeImage) CreateElement 

func (e *TagSvgFeImage) CreateElement() (ref *TagSvgFeImage)

func (*TagSvgFeImage) Cursor 

func (e *TagSvgFeImage) Cursor(cursor SvgCursor) (ref *TagSvgFeImage)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgFeImage) Direction 

func (e *TagSvgFeImage) Direction(direction SvgDirection) (ref *TagSvgFeImage)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgFeImage) Display 

func (e *TagSvgFeImage) Display(value interface{}) (ref *TagSvgFeImage)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgFeImage) DominantBaseline 

func (e *TagSvgFeImage) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgFeImage)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgFeImage) Fill 

func (e *TagSvgFeImage) Fill(value interface{}) (ref *TagSvgFeImage)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgFeImage) FillOpacity 

func (e *TagSvgFeImage) FillOpacity(value interface{}) (ref *TagSvgFeImage)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgFeImage) FillRule 

func (e *TagSvgFeImage) FillRule(fillRule SvgFillRule) (ref *TagSvgFeImage)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgFeImage) Filter 

func (e *TagSvgFeImage) Filter(filter string) (ref *TagSvgFeImage)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgFeImage) FloodColor 

func (e *TagSvgFeImage) FloodColor(floodColor interface{}) (ref *TagSvgFeImage)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgFeImage) FloodOpacity 

func (e *TagSvgFeImage) FloodOpacity(floodOpacity float64) (ref *TagSvgFeImage)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgFeImage) FontFamily 

func (e *TagSvgFeImage) FontFamily(fontFamily string) (ref *TagSvgFeImage)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgFeImage) FontSize 

func (e *TagSvgFeImage) FontSize(fontSize interface{}) (ref *TagSvgFeImage)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgFeImage) FontSizeAdjust 

func (e *TagSvgFeImage) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgFeImage)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgFeImage) FontStretch 

func (e *TagSvgFeImage) FontStretch(fontStretch interface{}) (ref *TagSvgFeImage)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgFeImage) FontStyle 

func (e *TagSvgFeImage) FontStyle(fontStyle FontStyleRule) (ref *TagSvgFeImage)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgFeImage) FontVariant 

func (e *TagSvgFeImage) FontVariant(value interface{}) (ref *TagSvgFeImage)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgFeImage) FontWeight 

func (e *TagSvgFeImage) FontWeight(value interface{}) (ref *TagSvgFeImage)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgFeImage) Get 

func (e *TagSvgFeImage) Get() (el js.Value)

func (*TagSvgFeImage) HRef 

func (e *TagSvgFeImage) HRef(href string) (ref *TagSvgFeImage)

HRef

English: 

The href attribute defines a link to a resource as a reference URL. The exact meaning of that link depends on the
context of each element using it.

 Notes:
   * Specifications before SVG 2 defined an xlink:href attribute, which is now rendered obsolete by the href
     attribute.
     If you need to support earlier browser versions, the deprecated xlink:href attribute can be used as a fallback
     in addition to the href attribute, e.g. <use href="some-id" xlink:href="some-id x="5" y="5" />.

Português: 

O atributo href define um link para um recurso como um URL de referência. O significado exato desse link depende do
contexto de cada elemento que o utiliza.

 Notas:
   * As especificações anteriores ao SVG 2 definiam um atributo xlink:href, que agora se torna obsoleto pelo
     atributo href.
     Se você precisar oferecer suporte a versões anteriores do navegador, o atributo obsoleto xlink:href pode ser
     usado como um substituto além do atributo href, por exemplo,
     <use href="some-id" xlink:href="some-id x="5" y="5" />.

func (*TagSvgFeImage) Height 

func (e *TagSvgFeImage) Height(height interface{}) (ref *TagSvgFeImage)

Height

English: 

The height attribute defines the vertical length of an element in the user coordinate system.
     float32: 1.0 = "100%"
     any other type: interface{}

Português: 

O atributo height define o comprimento vertical de um elemento no sistema de coordenadas do usuário.
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

func (*TagSvgFeImage) Html 

func (e *TagSvgFeImage) Html(value string) (ref *TagSvgFeImage)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgFeImage) Id 

func (e *TagSvgFeImage) Id(id string) (ref *TagSvgFeImage)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgFeImage) ImageRendering 

func (e *TagSvgFeImage) ImageRendering(imageRendering string) (ref *TagSvgFeImage)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgFeImage) Init 

func (e *TagSvgFeImage) Init() (ref *TagSvgFeImage)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgFeImage) Lang 

func (e *TagSvgFeImage) Lang(value interface{}) (ref *TagSvgFeImage)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgFeImage) LetterSpacing 

func (e *TagSvgFeImage) LetterSpacing(value float64) (ref *TagSvgFeImage)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgFeImage) LightingColor 

func (e *TagSvgFeImage) LightingColor(value interface{}) (ref *TagSvgFeImage)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgFeImage) MarkerEnd 

func (e *TagSvgFeImage) MarkerEnd(value interface{}) (ref *TagSvgFeImage)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgFeImage) MarkerMid 

func (e *TagSvgFeImage) MarkerMid(value interface{}) (ref *TagSvgFeImage)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgFeImage) MarkerStart 

func (e *TagSvgFeImage) MarkerStart(value interface{}) (ref *TagSvgFeImage)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgFeImage) Mask 

func (e *TagSvgFeImage) Mask(value interface{}) (ref *TagSvgFeImage)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgFeImage) Opacity 

func (e *TagSvgFeImage) Opacity(value interface{}) (ref *TagSvgFeImage)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgFeImage) Overflow 

func (e *TagSvgFeImage) Overflow(value interface{}) (ref *TagSvgFeImage)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgFeImage) PointerEvents 

func (e *TagSvgFeImage) PointerEvents(value interface{}) (ref *TagSvgFeImage)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgFeImage) PreserveAspectRatio 

func (e *TagSvgFeImage) PreserveAspectRatio(ratio, meet interface{}) (ref *TagSvgFeImage)

PreserveAspectRatio

English: 

The preserveAspectRatio attribute indicates how an element with a viewBox providing a given aspect ratio must fit
into a viewport with a different aspect ratio.

 Input:
   ratio: Indicates how an element with a viewBox providing a given aspect ratio.
     const: KRatio... (e.g. KRatioXMinYMin)
     any other type: interface{}
   meet: The meet or slice reference
     const: KMeetOrSliceReference... (e.g. KMeetOrSliceReferenceSlice)
     any other type: interface{}

Because the aspect ratio of an SVG image is defined by the viewBox attribute, if this attribute isn't set, the preserveAspectRatio attribute has no effect (with one exception, the <image> element, as described below).

Português: 

O atributo preserveAspectRatio indica como um elemento com uma viewBox fornecendo uma determinada proporção deve
caber em uma viewport com uma proporção diferente.

 Input:
   ratio: Indica como um elemento com uma viewBox fornece uma determinada proporção.
     const: KRatio... (ex. KRatioXMinYMin)
     qualquer outro tipo: interface{}
   meet: A referência de encontro ou fatia
     const: KMeetOrSliceReference... (ex. KMeetOrSliceReferenceSlice)
     qualquer outro tipo: interface{}

Como a proporção de uma imagem SVG é definida pelo atributo viewBox, se esse atributo não estiver definido, o atributo preserveAspectRatio não terá efeito (com uma exceção, o elemento <image>, conforme descrito abaixo).

func (*TagSvgFeImage) Result 

func (e *TagSvgFeImage) Result(value interface{}) (ref *TagSvgFeImage)

Result

English:

The result attribute defines the assigned name for this filter primitive. If supplied, then graphics that result from processing this filter primitive can be referenced by an in attribute on a subsequent filter primitive within the same <filter> element. If no value is provided, the output will only be available for re-use as the implicit input into the next filter primitive if that filter primitive provides no value for its in attribute.

Português:

O atributo result define o nome atribuído para esta primitiva de filtro. Se fornecido, os gráficos resultantes do processamento dessa primitiva de filtro podem ser referenciados por um atributo in em uma primitiva de filtro subsequente dentro do mesmo elemento <filter>. Se nenhum valor for fornecido, a saída só estará disponível para reutilização como entrada implícita na próxima primitiva de filtro se essa primitiva de filtro não fornecer valor para seu atributo in.

func (*TagSvgFeImage) ShapeRendering 

func (e *TagSvgFeImage) ShapeRendering(value interface{}) (ref *TagSvgFeImage)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgFeImage) StopColor 

func (e *TagSvgFeImage) StopColor(value interface{}) (ref *TagSvgFeImage)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgFeImage) StopOpacity 

func (e *TagSvgFeImage) StopOpacity(value interface{}) (ref *TagSvgFeImage)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgFeImage) Stroke 

func (e *TagSvgFeImage) Stroke(value interface{}) (ref *TagSvgFeImage)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgFeImage) StrokeDasharray 

func (e *TagSvgFeImage) StrokeDasharray(value interface{}) (ref *TagSvgFeImage)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgFeImage) StrokeLineCap 

func (e *TagSvgFeImage) StrokeLineCap(value interface{}) (ref *TagSvgFeImage)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgFeImage) StrokeLineJoin 

func (e *TagSvgFeImage) StrokeLineJoin(value interface{}) (ref *TagSvgFeImage)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgFeImage) StrokeMiterLimit 

func (e *TagSvgFeImage) StrokeMiterLimit(value float64) (ref *TagSvgFeImage)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgFeImage) StrokeOpacity 

func (e *TagSvgFeImage) StrokeOpacity(value interface{}) (ref *TagSvgFeImage)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgFeImage) StrokeWidth 

func (e *TagSvgFeImage) StrokeWidth(value interface{}) (ref *TagSvgFeImage)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeImage) Style 

func (e *TagSvgFeImage) Style(value string) (ref *TagSvgFeImage)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgFeImage) Tabindex 

func (e *TagSvgFeImage) Tabindex(value int) (ref *TagSvgFeImage)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgFeImage) Text 

func (e *TagSvgFeImage) Text(value string) (ref *TagSvgFeImage)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgFeImage) TextAnchor 

func (e *TagSvgFeImage) TextAnchor(value interface{}) (ref *TagSvgFeImage)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgFeImage) TextDecoration 

func (e *TagSvgFeImage) TextDecoration(value interface{}) (ref *TagSvgFeImage)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgFeImage) TextRendering 

func (e *TagSvgFeImage) TextRendering(value interface{}) (ref *TagSvgFeImage)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgFeImage) Transform 

func (e *TagSvgFeImage) Transform(value interface{}) (ref *TagSvgFeImage)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgFeImage) UnicodeBidi 

func (e *TagSvgFeImage) UnicodeBidi(value interface{}) (ref *TagSvgFeImage)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgFeImage) VectorEffect 

func (e *TagSvgFeImage) VectorEffect(value interface{}) (ref *TagSvgFeImage)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgFeImage) Visibility 

func (e *TagSvgFeImage) Visibility(value interface{}) (ref *TagSvgFeImage)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgFeImage) Width 

func (e *TagSvgFeImage) Width(value interface{}) (ref *TagSvgFeImage)

Width

English:

The width attribute defines the horizontal length of an element in the user coordinate system. 

Input:
  value: the horizontal length of an element
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo largura define o comprimento horizontal de um elemento no sistema de coordenadas do usuário. 

Entrada:
  value: o comprimento horizontal de um elemento
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeImage) WordSpacing 

func (e *TagSvgFeImage) WordSpacing(value interface{}) (ref *TagSvgFeImage)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgFeImage) WritingMode 

func (e *TagSvgFeImage) WritingMode(value interface{}) (ref *TagSvgFeImage)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgFeImage) X 

func (e *TagSvgFeImage) X(value interface{}) (ref *TagSvgFeImage)

X

English:

The x attribute defines an x-axis coordinate in the user coordinate system. 

Input:
  value: defines an x-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo x define uma coordenada do eixo x no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo x
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgFeImage) XLinkHRef deprecated 

func (e *TagSvgFeImage) XLinkHRef(value interface{}) (ref *TagSvgFeImage)

XLinkHRef

English:

Deprecated: use HRef() function

The xlink:href attribute defines a reference to a resource as a reference IRI. The exact meaning of that link depends on the context of each element using it. 

Notes:
  * SVG 2 removed the need for the xlink namespace, so instead of xlink:href you should use href. If you need to
    support earlier browser versions, the deprecated xlink:href attribute can be used as a fallback in addition to
    the href attribute, e.g. <use href="some-id" xlink:href="some-id" x="5" y="5" />.

Português:

Obsoleto: use a função HRef()

O atributo xlink:href define uma referência a um recurso como um IRI de referência. O significado exato desse link depende do contexto de cada elemento que o utiliza. 

Notas:
  * O SVG 2 removeu a necessidade do namespace xlink, então ao invés de xlink:href você deve usar href. Se você
    precisar oferecer suporte a versões anteriores do navegador, o atributo obsoleto xlink:href pode ser usado como
    um substituto além do atributo href, por exemplo, <use href="some-id" xlink:href="some-id" x="5" y="5" >.

func (*TagSvgFeImage) XmlLang 

func (e *TagSvgFeImage) XmlLang(value interface{}) (ref *TagSvgFeImage)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

func (*TagSvgFeImage) Y 

func (e *TagSvgFeImage) Y(value interface{}) (ref *TagSvgFeImage)

Y

English:

The y attribute defines an y-axis coordinate in the user coordinate system. 

Input:
  value: defines an y-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo y define uma coordenada do eixo y no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo y
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

type TagSvgFeMerge 

type TagSvgFeMerge struct {
	// contains filtered or unexported fields
}

TagSvgFeMerge

English:

The <feMerge> SVG element allows filter effects to be applied concurrently instead of sequentially. This is achieved by other filters storing their output via the result attribute and then accessing it in a <feMergeNode> child.

Português:

O elemento SVG <feMerge> permite que efeitos de filtro sejam aplicados simultaneamente em vez de sequencialmente. Isso é obtido por outros filtros armazenando sua saída por meio do atributo result e acessando-a em um filho <feMergeNode>.

func (*TagSvgFeMerge) Append 

func (e *TagSvgFeMerge) Append(elements ...Compatible) (ref *TagSvgFeMerge)

func (*TagSvgFeMerge) AppendById 

func (e *TagSvgFeMerge) AppendById(appendId string) (ref *TagSvgFeMerge)

func (*TagSvgFeMerge) AppendToElement 

func (e *TagSvgFeMerge) AppendToElement(el js.Value) (ref *TagSvgFeMerge)

func (*TagSvgFeMerge) AppendToStage 

func (e *TagSvgFeMerge) AppendToStage() (ref *TagSvgFeMerge)

func (*TagSvgFeMerge) BaselineShift 

func (e *TagSvgFeMerge) BaselineShift(baselineShift interface{}) (ref *TagSvgFeMerge)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgFeMerge) Class 

func (e *TagSvgFeMerge) Class(class string) (ref *TagSvgFeMerge)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgFeMerge) ClipPath 

func (e *TagSvgFeMerge) ClipPath(clipPath string) (ref *TagSvgFeMerge)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgFeMerge) ClipRule 

func (e *TagSvgFeMerge) ClipRule(value interface{}) (ref *TagSvgFeMerge)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgFeMerge) Color 

func (e *TagSvgFeMerge) Color(value interface{}) (ref *TagSvgFeMerge)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgFeMerge) ColorInterpolation 

func (e *TagSvgFeMerge) ColorInterpolation(value interface{}) (ref *TagSvgFeMerge)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgFeMerge) ColorInterpolationFilters 

func (e *TagSvgFeMerge) ColorInterpolationFilters(value interface{}) (ref *TagSvgFeMerge)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgFeMerge) CreateElement 

func (e *TagSvgFeMerge) CreateElement() (ref *TagSvgFeMerge)

func (*TagSvgFeMerge) Cursor 

func (e *TagSvgFeMerge) Cursor(cursor SvgCursor) (ref *TagSvgFeMerge)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgFeMerge) Direction 

func (e *TagSvgFeMerge) Direction(direction SvgDirection) (ref *TagSvgFeMerge)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgFeMerge) Display 

func (e *TagSvgFeMerge) Display(value interface{}) (ref *TagSvgFeMerge)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgFeMerge) DominantBaseline 

func (e *TagSvgFeMerge) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgFeMerge)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgFeMerge) Fill 

func (e *TagSvgFeMerge) Fill(value interface{}) (ref *TagSvgFeMerge)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgFeMerge) FillOpacity 

func (e *TagSvgFeMerge) FillOpacity(value interface{}) (ref *TagSvgFeMerge)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgFeMerge) FillRule 

func (e *TagSvgFeMerge) FillRule(fillRule SvgFillRule) (ref *TagSvgFeMerge)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgFeMerge) Filter 

func (e *TagSvgFeMerge) Filter(filter string) (ref *TagSvgFeMerge)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgFeMerge) FloodColor 

func (e *TagSvgFeMerge) FloodColor(floodColor interface{}) (ref *TagSvgFeMerge)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgFeMerge) FloodOpacity 

func (e *TagSvgFeMerge) FloodOpacity(floodOpacity float64) (ref *TagSvgFeMerge)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgFeMerge) FontFamily 

func (e *TagSvgFeMerge) FontFamily(fontFamily string) (ref *TagSvgFeMerge)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgFeMerge) FontSize 

func (e *TagSvgFeMerge) FontSize(fontSize interface{}) (ref *TagSvgFeMerge)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgFeMerge) FontSizeAdjust 

func (e *TagSvgFeMerge) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgFeMerge)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgFeMerge) FontStretch 

func (e *TagSvgFeMerge) FontStretch(fontStretch interface{}) (ref *TagSvgFeMerge)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgFeMerge) FontStyle 

func (e *TagSvgFeMerge) FontStyle(fontStyle FontStyleRule) (ref *TagSvgFeMerge)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgFeMerge) FontVariant 

func (e *TagSvgFeMerge) FontVariant(value interface{}) (ref *TagSvgFeMerge)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgFeMerge) FontWeight 

func (e *TagSvgFeMerge) FontWeight(value interface{}) (ref *TagSvgFeMerge)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgFeMerge) Get 

func (e *TagSvgFeMerge) Get() (el js.Value)

func (*TagSvgFeMerge) Height 

func (e *TagSvgFeMerge) Height(height interface{}) (ref *TagSvgFeMerge)

Height

English: 

The height attribute defines the vertical length of an element in the user coordinate system.
     float32: 1.0 = "100%"
     any other type: interface{}

Português: 

O atributo height define o comprimento vertical de um elemento no sistema de coordenadas do usuário.
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

func (*TagSvgFeMerge) Html 

func (e *TagSvgFeMerge) Html(value string) (ref *TagSvgFeMerge)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgFeMerge) Id 

func (e *TagSvgFeMerge) Id(id string) (ref *TagSvgFeMerge)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgFeMerge) ImageRendering 

func (e *TagSvgFeMerge) ImageRendering(imageRendering string) (ref *TagSvgFeMerge)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgFeMerge) Init 

func (e *TagSvgFeMerge) Init() (ref *TagSvgFeMerge)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgFeMerge) Lang 

func (e *TagSvgFeMerge) Lang(value interface{}) (ref *TagSvgFeMerge)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgFeMerge) LetterSpacing 

func (e *TagSvgFeMerge) LetterSpacing(value float64) (ref *TagSvgFeMerge)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgFeMerge) LightingColor 

func (e *TagSvgFeMerge) LightingColor(value interface{}) (ref *TagSvgFeMerge)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgFeMerge) MarkerEnd 

func (e *TagSvgFeMerge) MarkerEnd(value interface{}) (ref *TagSvgFeMerge)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgFeMerge) MarkerMid 

func (e *TagSvgFeMerge) MarkerMid(value interface{}) (ref *TagSvgFeMerge)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgFeMerge) MarkerStart 

func (e *TagSvgFeMerge) MarkerStart(value interface{}) (ref *TagSvgFeMerge)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgFeMerge) Mask 

func (e *TagSvgFeMerge) Mask(value interface{}) (ref *TagSvgFeMerge)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgFeMerge) Opacity 

func (e *TagSvgFeMerge) Opacity(value interface{}) (ref *TagSvgFeMerge)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgFeMerge) Overflow 

func (e *TagSvgFeMerge) Overflow(value interface{}) (ref *TagSvgFeMerge)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgFeMerge) PointerEvents 

func (e *TagSvgFeMerge) PointerEvents(value interface{}) (ref *TagSvgFeMerge)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgFeMerge) Result 

func (e *TagSvgFeMerge) Result(value interface{}) (ref *TagSvgFeMerge)

Result

English:

The result attribute defines the assigned name for this filter primitive. If supplied, then graphics that result from processing this filter primitive can be referenced by an in attribute on a subsequent filter primitive within the same <filter> element. If no value is provided, the output will only be available for re-use as the implicit input into the next filter primitive if that filter primitive provides no value for its in attribute.

Português:

O atributo result define o nome atribuído para esta primitiva de filtro. Se fornecido, os gráficos resultantes do processamento dessa primitiva de filtro podem ser referenciados por um atributo in em uma primitiva de filtro subsequente dentro do mesmo elemento <filter>. Se nenhum valor for fornecido, a saída só estará disponível para reutilização como entrada implícita na próxima primitiva de filtro se essa primitiva de filtro não fornecer valor para seu atributo in.

func (*TagSvgFeMerge) ShapeRendering 

func (e *TagSvgFeMerge) ShapeRendering(value interface{}) (ref *TagSvgFeMerge)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgFeMerge) StopColor 

func (e *TagSvgFeMerge) StopColor(value interface{}) (ref *TagSvgFeMerge)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgFeMerge) StopOpacity 

func (e *TagSvgFeMerge) StopOpacity(value interface{}) (ref *TagSvgFeMerge)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgFeMerge) Stroke 

func (e *TagSvgFeMerge) Stroke(value interface{}) (ref *TagSvgFeMerge)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgFeMerge) StrokeDasharray 

func (e *TagSvgFeMerge) StrokeDasharray(value interface{}) (ref *TagSvgFeMerge)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgFeMerge) StrokeLineCap 

func (e *TagSvgFeMerge) StrokeLineCap(value interface{}) (ref *TagSvgFeMerge)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgFeMerge) StrokeLineJoin 

func (e *TagSvgFeMerge) StrokeLineJoin(value interface{}) (ref *TagSvgFeMerge)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgFeMerge) StrokeMiterLimit 

func (e *TagSvgFeMerge) StrokeMiterLimit(value float64) (ref *TagSvgFeMerge)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgFeMerge) StrokeOpacity 

func (e *TagSvgFeMerge) StrokeOpacity(value interface{}) (ref *TagSvgFeMerge)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgFeMerge) StrokeWidth 

func (e *TagSvgFeMerge) StrokeWidth(value interface{}) (ref *TagSvgFeMerge)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeMerge) Style 

func (e *TagSvgFeMerge) Style(value string) (ref *TagSvgFeMerge)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgFeMerge) Tabindex 

func (e *TagSvgFeMerge) Tabindex(value int) (ref *TagSvgFeMerge)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgFeMerge) Text 

func (e *TagSvgFeMerge) Text(value string) (ref *TagSvgFeMerge)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgFeMerge) TextAnchor 

func (e *TagSvgFeMerge) TextAnchor(value interface{}) (ref *TagSvgFeMerge)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgFeMerge) TextDecoration 

func (e *TagSvgFeMerge) TextDecoration(value interface{}) (ref *TagSvgFeMerge)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgFeMerge) TextRendering 

func (e *TagSvgFeMerge) TextRendering(value interface{}) (ref *TagSvgFeMerge)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgFeMerge) Transform 

func (e *TagSvgFeMerge) Transform(value interface{}) (ref *TagSvgFeMerge)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgFeMerge) UnicodeBidi 

func (e *TagSvgFeMerge) UnicodeBidi(value interface{}) (ref *TagSvgFeMerge)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgFeMerge) VectorEffect 

func (e *TagSvgFeMerge) VectorEffect(value interface{}) (ref *TagSvgFeMerge)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgFeMerge) Visibility 

func (e *TagSvgFeMerge) Visibility(value interface{}) (ref *TagSvgFeMerge)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgFeMerge) Width 

func (e *TagSvgFeMerge) Width(value interface{}) (ref *TagSvgFeMerge)

Width

English:

The width attribute defines the horizontal length of an element in the user coordinate system. 

Input:
  value: the horizontal length of an element
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo largura define o comprimento horizontal de um elemento no sistema de coordenadas do usuário. 

Entrada:
  value: o comprimento horizontal de um elemento
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeMerge) WordSpacing 

func (e *TagSvgFeMerge) WordSpacing(value interface{}) (ref *TagSvgFeMerge)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgFeMerge) WritingMode 

func (e *TagSvgFeMerge) WritingMode(value interface{}) (ref *TagSvgFeMerge)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgFeMerge) X 

func (e *TagSvgFeMerge) X(value interface{}) (ref *TagSvgFeMerge)

X

English:

The x attribute defines an x-axis coordinate in the user coordinate system. 

Input:
  value: defines an x-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo x define uma coordenada do eixo x no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo x
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgFeMerge) XmlLang 

func (e *TagSvgFeMerge) XmlLang(value interface{}) (ref *TagSvgFeMerge)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

func (*TagSvgFeMerge) Y 

func (e *TagSvgFeMerge) Y(value interface{}) (ref *TagSvgFeMerge)

Y

English:

The y attribute defines an y-axis coordinate in the user coordinate system. 

Input:
  value: defines an y-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo y define uma coordenada do eixo y no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo y
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

type TagSvgFeMergeNode 

type TagSvgFeMergeNode struct {
	// contains filtered or unexported fields
}

TagSvgFeMergeNode

English:

The feMergeNode takes the result of another filter to be processed by its parent <feMerge>.

Português:

O feMergeNode recebe o resultado de outro filtro para ser processado por seu pai <feMerge>.

func (*TagSvgFeMergeNode) Append 

func (e *TagSvgFeMergeNode) Append(elements ...Compatible) (ref *TagSvgFeMergeNode)

func (*TagSvgFeMergeNode) AppendById 

func (e *TagSvgFeMergeNode) AppendById(appendId string) (ref *TagSvgFeMergeNode)

func (*TagSvgFeMergeNode) AppendToElement 

func (e *TagSvgFeMergeNode) AppendToElement(el js.Value) (ref *TagSvgFeMergeNode)

func (*TagSvgFeMergeNode) AppendToStage 

func (e *TagSvgFeMergeNode) AppendToStage() (ref *TagSvgFeMergeNode)

func (*TagSvgFeMergeNode) CreateElement 

func (e *TagSvgFeMergeNode) CreateElement() (ref *TagSvgFeMergeNode)

func (*TagSvgFeMergeNode) Get 

func (e *TagSvgFeMergeNode) Get() (el js.Value)

func (*TagSvgFeMergeNode) Html 

func (e *TagSvgFeMergeNode) Html(value string) (ref *TagSvgFeMergeNode)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgFeMergeNode) Id 

func (e *TagSvgFeMergeNode) Id(id string) (ref *TagSvgFeMergeNode)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgFeMergeNode) In 

func (e *TagSvgFeMergeNode) In(in interface{}) (ref *TagSvgFeMergeNode)

In

English: 

The in attribute identifies input for the given filter primitive.

 Input:
   in: identifies input for the given filter primitive.
     KSvgIn... (e.g. KSvgInSourceAlpha)
     any other type: interface{}

The value can be either one of the six keywords defined below, or a string which matches a previous result attribute value within the same <filter> element. If no value is provided and this is the first filter primitive, then this filter primitive will use SourceGraphic as its input. If no value is provided and this is a subsequent filter primitive, then this filter primitive will use the result from the previous filter primitive as its input.

If the value for result appears multiple times within a given <filter> element, then a reference to that result will use the closest preceding filter primitive with the given value for attribute result.

Portuguese 

O atributo in identifica à entrada para a primitiva de filtro fornecida.

 Entrada:
   in: identifica à entrada para a primitiva de filtro fornecida.
     KSvgIn... (e.g. KSvgInSourceAlpha)
     qualquer outro tipo: interface{}

O valor pode ser uma das seis palavras-chave definidas abaixo ou uma string que corresponda a um valor de atributo de resultado anterior dentro do mesmo elemento <filter>. Se nenhum valor for fornecido e esta for a primeira primitiva de filtro, essa primitiva de filtro usará SourceGraphic como sua entrada. Se nenhum valor for fornecido e esta for uma primitiva de filtro subsequente, essa primitiva de filtro usará o resultado da primitiva de filtro anterior como sua entrada.

Se o valor do resultado aparecer várias vezes em um determinado elemento <filter>, uma referência à esse resultado usará a primitiva de filtro anterior mais próxima com o valor fornecido para o resultado do atributo.

func (*TagSvgFeMergeNode) Init 

func (e *TagSvgFeMergeNode) Init() (ref *TagSvgFeMergeNode)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgFeMergeNode) Lang 

func (e *TagSvgFeMergeNode) Lang(value interface{}) (ref *TagSvgFeMergeNode)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgFeMergeNode) Tabindex 

func (e *TagSvgFeMergeNode) Tabindex(value int) (ref *TagSvgFeMergeNode)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgFeMergeNode) Text 

func (e *TagSvgFeMergeNode) Text(value string) (ref *TagSvgFeMergeNode)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgFeMergeNode) XmlLang 

func (e *TagSvgFeMergeNode) XmlLang(value interface{}) (ref *TagSvgFeMergeNode)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

type TagSvgFeMorphology 

type TagSvgFeMorphology struct {
	// contains filtered or unexported fields
}

TagSvgFeMorphology

English:

The <feMorphology> SVG filter primitive is used to erode or dilate the input image. Its usefulness lies especially in fattening or thinning effects.

Português:

A primitiva de filtro SVG <feMorphology> é usada para corroer ou dilatar a imagem de entrada. Sua utilidade reside especialmente nos efeitos de engorda ou desbaste.

func (*TagSvgFeMorphology) Append 

func (e *TagSvgFeMorphology) Append(elements ...Compatible) (ref *TagSvgFeMorphology)

func (*TagSvgFeMorphology) AppendById 

func (e *TagSvgFeMorphology) AppendById(appendId string) (ref *TagSvgFeMorphology)

func (*TagSvgFeMorphology) AppendToElement 

func (e *TagSvgFeMorphology) AppendToElement(el js.Value) (ref *TagSvgFeMorphology)

func (*TagSvgFeMorphology) AppendToStage 

func (e *TagSvgFeMorphology) AppendToStage() (ref *TagSvgFeMorphology)

func (*TagSvgFeMorphology) BaselineShift 

func (e *TagSvgFeMorphology) BaselineShift(baselineShift interface{}) (ref *TagSvgFeMorphology)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgFeMorphology) Class 

func (e *TagSvgFeMorphology) Class(class string) (ref *TagSvgFeMorphology)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgFeMorphology) ClipPath 

func (e *TagSvgFeMorphology) ClipPath(clipPath string) (ref *TagSvgFeMorphology)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgFeMorphology) ClipRule 

func (e *TagSvgFeMorphology) ClipRule(value interface{}) (ref *TagSvgFeMorphology)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgFeMorphology) Color 

func (e *TagSvgFeMorphology) Color(value interface{}) (ref *TagSvgFeMorphology)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgFeMorphology) ColorInterpolation 

func (e *TagSvgFeMorphology) ColorInterpolation(value interface{}) (ref *TagSvgFeMorphology)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgFeMorphology) ColorInterpolationFilters 

func (e *TagSvgFeMorphology) ColorInterpolationFilters(value interface{}) (ref *TagSvgFeMorphology)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgFeMorphology) CreateElement 

func (e *TagSvgFeMorphology) CreateElement() (ref *TagSvgFeMorphology)

func (*TagSvgFeMorphology) Cursor 

func (e *TagSvgFeMorphology) Cursor(cursor SvgCursor) (ref *TagSvgFeMorphology)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgFeMorphology) Direction 

func (e *TagSvgFeMorphology) Direction(direction SvgDirection) (ref *TagSvgFeMorphology)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgFeMorphology) Display 

func (e *TagSvgFeMorphology) Display(value interface{}) (ref *TagSvgFeMorphology)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgFeMorphology) DominantBaseline 

func (e *TagSvgFeMorphology) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgFeMorphology)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgFeMorphology) Fill 

func (e *TagSvgFeMorphology) Fill(value interface{}) (ref *TagSvgFeMorphology)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgFeMorphology) FillOpacity 

func (e *TagSvgFeMorphology) FillOpacity(value interface{}) (ref *TagSvgFeMorphology)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgFeMorphology) FillRule 

func (e *TagSvgFeMorphology) FillRule(fillRule SvgFillRule) (ref *TagSvgFeMorphology)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgFeMorphology) Filter 

func (e *TagSvgFeMorphology) Filter(filter string) (ref *TagSvgFeMorphology)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgFeMorphology) FloodColor 

func (e *TagSvgFeMorphology) FloodColor(floodColor interface{}) (ref *TagSvgFeMorphology)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgFeMorphology) FloodOpacity 

func (e *TagSvgFeMorphology) FloodOpacity(floodOpacity float64) (ref *TagSvgFeMorphology)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgFeMorphology) FontFamily 

func (e *TagSvgFeMorphology) FontFamily(fontFamily string) (ref *TagSvgFeMorphology)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgFeMorphology) FontSize 

func (e *TagSvgFeMorphology) FontSize(fontSize interface{}) (ref *TagSvgFeMorphology)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgFeMorphology) FontSizeAdjust 

func (e *TagSvgFeMorphology) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgFeMorphology)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgFeMorphology) FontStretch 

func (e *TagSvgFeMorphology) FontStretch(fontStretch interface{}) (ref *TagSvgFeMorphology)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgFeMorphology) FontStyle 

func (e *TagSvgFeMorphology) FontStyle(fontStyle FontStyleRule) (ref *TagSvgFeMorphology)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgFeMorphology) FontVariant 

func (e *TagSvgFeMorphology) FontVariant(value interface{}) (ref *TagSvgFeMorphology)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgFeMorphology) FontWeight 

func (e *TagSvgFeMorphology) FontWeight(value interface{}) (ref *TagSvgFeMorphology)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgFeMorphology) Get 

func (e *TagSvgFeMorphology) Get() (el js.Value)

func (*TagSvgFeMorphology) Height 

func (e *TagSvgFeMorphology) Height(height interface{}) (ref *TagSvgFeMorphology)

Height

English: 

The height attribute defines the vertical length of an element in the user coordinate system.
     float32: 1.0 = "100%"
     any other type: interface{}

Português: 

O atributo height define o comprimento vertical de um elemento no sistema de coordenadas do usuário.
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

func (*TagSvgFeMorphology) Html 

func (e *TagSvgFeMorphology) Html(value string) (ref *TagSvgFeMorphology)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgFeMorphology) Id 

func (e *TagSvgFeMorphology) Id(id string) (ref *TagSvgFeMorphology)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgFeMorphology) ImageRendering 

func (e *TagSvgFeMorphology) ImageRendering(imageRendering string) (ref *TagSvgFeMorphology)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgFeMorphology) In 

func (e *TagSvgFeMorphology) In(in interface{}) (ref *TagSvgFeMorphology)

In

English: 

The in attribute identifies input for the given filter primitive.

 Input:
   in: identifies input for the given filter primitive.
     KSvgIn... (e.g. KSvgInSourceAlpha)
     any other type: interface{}

The value can be either one of the six keywords defined below, or a string which matches a previous result attribute value within the same <filter> element. If no value is provided and this is the first filter primitive, then this filter primitive will use SourceGraphic as its input. If no value is provided and this is a subsequent filter primitive, then this filter primitive will use the result from the previous filter primitive as its input.

If the value for result appears multiple times within a given <filter> element, then a reference to that result will use the closest preceding filter primitive with the given value for attribute result.

Portuguese 

O atributo in identifica à entrada para a primitiva de filtro fornecida.

 Entrada:
   in: identifica à entrada para a primitiva de filtro fornecida.
     KSvgIn... (e.g. KSvgInSourceAlpha)
     qualquer outro tipo: interface{}

O valor pode ser uma das seis palavras-chave definidas abaixo ou uma string que corresponda a um valor de atributo de resultado anterior dentro do mesmo elemento <filter>. Se nenhum valor for fornecido e esta for a primeira primitiva de filtro, essa primitiva de filtro usará SourceGraphic como sua entrada. Se nenhum valor for fornecido e esta for uma primitiva de filtro subsequente, essa primitiva de filtro usará o resultado da primitiva de filtro anterior como sua entrada.

Se o valor do resultado aparecer várias vezes em um determinado elemento <filter>, uma referência à esse resultado usará a primitiva de filtro anterior mais próxima com o valor fornecido para o resultado do atributo.

func (*TagSvgFeMorphology) Init 

func (e *TagSvgFeMorphology) Init() (ref *TagSvgFeMorphology)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgFeMorphology) Lang 

func (e *TagSvgFeMorphology) Lang(value interface{}) (ref *TagSvgFeMorphology)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgFeMorphology) LetterSpacing 

func (e *TagSvgFeMorphology) LetterSpacing(value float64) (ref *TagSvgFeMorphology)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgFeMorphology) LightingColor 

func (e *TagSvgFeMorphology) LightingColor(value interface{}) (ref *TagSvgFeMorphology)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgFeMorphology) MarkerEnd 

func (e *TagSvgFeMorphology) MarkerEnd(value interface{}) (ref *TagSvgFeMorphology)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgFeMorphology) MarkerMid 

func (e *TagSvgFeMorphology) MarkerMid(value interface{}) (ref *TagSvgFeMorphology)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgFeMorphology) MarkerStart 

func (e *TagSvgFeMorphology) MarkerStart(value interface{}) (ref *TagSvgFeMorphology)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgFeMorphology) Mask 

func (e *TagSvgFeMorphology) Mask(value interface{}) (ref *TagSvgFeMorphology)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgFeMorphology) Opacity 

func (e *TagSvgFeMorphology) Opacity(value interface{}) (ref *TagSvgFeMorphology)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgFeMorphology) Operator 

func (e *TagSvgFeMorphology) Operator(value interface{}) (ref *TagSvgFeMorphology)

Operator

English:

The operator attribute has two meanings based on the context it's used in. Either it defines the compositing or morphing operation to be performed. 

Input:
  value: defines the compositing or morphing
    const: KSvgOperatorFeMorphology... (e.g. KKSvgOperatorFeCompositeErode)

Português:

O atributo operador tem dois significados com base no contexto em que é usado. Ele define a operação de composição ou transformação a ser executada. 

Entrada:
  value: define a composição ou morphing
    const: KSvgOperatorFeMorphology... (e.g. KKSvgOperatorFeCompositeErode)

func (*TagSvgFeMorphology) Overflow 

func (e *TagSvgFeMorphology) Overflow(value interface{}) (ref *TagSvgFeMorphology)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgFeMorphology) PointerEvents 

func (e *TagSvgFeMorphology) PointerEvents(value interface{}) (ref *TagSvgFeMorphology)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgFeMorphology) Radius 

func (e *TagSvgFeMorphology) Radius(value interface{}) (ref *TagSvgFeMorphology)

Radius

English:

The radius attribute represents the radius (or radii) for the operation on a given <feMorphology> filter primitive.

If two numbers are provided, the first number represents the x-radius and the second one the y-radius. If one number is provided, then that value is used for both x and y. The values are in the coordinate system established by the primitiveUnits attribute on the <filter> element.

A negative or zero value disables the effect of the given filter primitive (i.e., the result is the filter input image).

Português:

O atributo radius representa o raio (ou raios) para a operação em uma determinada primitiva de filtro <feMorphology>.

Se dois números forem fornecidos, o primeiro número representa o raio x e o segundo o raio y. Se um número for fornecido, esse valor será usado para x e y. Os valores estão no sistema de coordenadas estabelecido pelo atributo primitivaUnits no elemento <filter>.

Um valor negativo ou zero desativa o efeito da primitiva de filtro fornecida (ou seja, o resultado é a imagem de entrada do filtro).

func (*TagSvgFeMorphology) Result 

func (e *TagSvgFeMorphology) Result(value interface{}) (ref *TagSvgFeMorphology)

Result

English:

The result attribute defines the assigned name for this filter primitive. If supplied, then graphics that result from processing this filter primitive can be referenced by an in attribute on a subsequent filter primitive within the same <filter> element. If no value is provided, the output will only be available for re-use as the implicit input into the next filter primitive if that filter primitive provides no value for its in attribute.

Português:

O atributo result define o nome atribuído para esta primitiva de filtro. Se fornecido, os gráficos resultantes do processamento dessa primitiva de filtro podem ser referenciados por um atributo in em uma primitiva de filtro subsequente dentro do mesmo elemento <filter>. Se nenhum valor for fornecido, a saída só estará disponível para reutilização como entrada implícita na próxima primitiva de filtro se essa primitiva de filtro não fornecer valor para seu atributo in.

func (*TagSvgFeMorphology) ShapeRendering 

func (e *TagSvgFeMorphology) ShapeRendering(value interface{}) (ref *TagSvgFeMorphology)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgFeMorphology) StopColor 

func (e *TagSvgFeMorphology) StopColor(value interface{}) (ref *TagSvgFeMorphology)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgFeMorphology) StopOpacity 

func (e *TagSvgFeMorphology) StopOpacity(value interface{}) (ref *TagSvgFeMorphology)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgFeMorphology) Stroke 

func (e *TagSvgFeMorphology) Stroke(value interface{}) (ref *TagSvgFeMorphology)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgFeMorphology) StrokeDasharray 

func (e *TagSvgFeMorphology) StrokeDasharray(value interface{}) (ref *TagSvgFeMorphology)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgFeMorphology) StrokeLineCap 

func (e *TagSvgFeMorphology) StrokeLineCap(value interface{}) (ref *TagSvgFeMorphology)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgFeMorphology) StrokeLineJoin 

func (e *TagSvgFeMorphology) StrokeLineJoin(value interface{}) (ref *TagSvgFeMorphology)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgFeMorphology) StrokeMiterLimit 

func (e *TagSvgFeMorphology) StrokeMiterLimit(value float64) (ref *TagSvgFeMorphology)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgFeMorphology) StrokeOpacity 

func (e *TagSvgFeMorphology) StrokeOpacity(value interface{}) (ref *TagSvgFeMorphology)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgFeMorphology) StrokeWidth 

func (e *TagSvgFeMorphology) StrokeWidth(value interface{}) (ref *TagSvgFeMorphology)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeMorphology) Style 

func (e *TagSvgFeMorphology) Style(value string) (ref *TagSvgFeMorphology)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgFeMorphology) Tabindex 

func (e *TagSvgFeMorphology) Tabindex(value int) (ref *TagSvgFeMorphology)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgFeMorphology) Text 

func (e *TagSvgFeMorphology) Text(value string) (ref *TagSvgFeMorphology)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgFeMorphology) TextAnchor 

func (e *TagSvgFeMorphology) TextAnchor(value interface{}) (ref *TagSvgFeMorphology)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgFeMorphology) TextDecoration 

func (e *TagSvgFeMorphology) TextDecoration(value interface{}) (ref *TagSvgFeMorphology)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgFeMorphology) TextRendering 

func (e *TagSvgFeMorphology) TextRendering(value interface{}) (ref *TagSvgFeMorphology)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgFeMorphology) Transform 

func (e *TagSvgFeMorphology) Transform(value interface{}) (ref *TagSvgFeMorphology)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgFeMorphology) UnicodeBidi 

func (e *TagSvgFeMorphology) UnicodeBidi(value interface{}) (ref *TagSvgFeMorphology)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgFeMorphology) VectorEffect 

func (e *TagSvgFeMorphology) VectorEffect(value interface{}) (ref *TagSvgFeMorphology)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgFeMorphology) Visibility 

func (e *TagSvgFeMorphology) Visibility(value interface{}) (ref *TagSvgFeMorphology)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgFeMorphology) Width 

func (e *TagSvgFeMorphology) Width(value interface{}) (ref *TagSvgFeMorphology)

Width

English:

The width attribute defines the horizontal length of an element in the user coordinate system. 

Input:
  value: the horizontal length of an element
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo largura define o comprimento horizontal de um elemento no sistema de coordenadas do usuário. 

Entrada:
  value: o comprimento horizontal de um elemento
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeMorphology) WordSpacing 

func (e *TagSvgFeMorphology) WordSpacing(value interface{}) (ref *TagSvgFeMorphology)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgFeMorphology) WritingMode 

func (e *TagSvgFeMorphology) WritingMode(value interface{}) (ref *TagSvgFeMorphology)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgFeMorphology) X 

func (e *TagSvgFeMorphology) X(value interface{}) (ref *TagSvgFeMorphology)

X

English:

The x attribute defines an x-axis coordinate in the user coordinate system. 

Input:
  value: defines an x-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo x define uma coordenada do eixo x no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo x
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgFeMorphology) XmlLang 

func (e *TagSvgFeMorphology) XmlLang(value interface{}) (ref *TagSvgFeMorphology)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

func (*TagSvgFeMorphology) Y 

func (e *TagSvgFeMorphology) Y(value interface{}) (ref *TagSvgFeMorphology)

Y

English:

The y attribute defines an y-axis coordinate in the user coordinate system. 

Input:
  value: defines an y-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo y define uma coordenada do eixo y no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo y
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

type TagSvgFeOffset 

type TagSvgFeOffset struct {
	// contains filtered or unexported fields
}

TagSvgFeOffset

English:

The <feOffset> SVG filter primitive allows to offset the input image. The input image as a whole is offset by the values specified in the dx and dy attributes.

Português:

A primitiva de filtro SVG <feOffset> permite deslocar a imagem de entrada. A imagem de entrada é compensada pelos valores especificados nos atributos dx e dy.

func (*TagSvgFeOffset) Append 

func (e *TagSvgFeOffset) Append(elements ...Compatible) (ref *TagSvgFeOffset)

func (*TagSvgFeOffset) AppendById 

func (e *TagSvgFeOffset) AppendById(appendId string) (ref *TagSvgFeOffset)

func (*TagSvgFeOffset) AppendToElement 

func (e *TagSvgFeOffset) AppendToElement(el js.Value) (ref *TagSvgFeOffset)

func (*TagSvgFeOffset) AppendToStage 

func (e *TagSvgFeOffset) AppendToStage() (ref *TagSvgFeOffset)

func (*TagSvgFeOffset) BaselineShift 

func (e *TagSvgFeOffset) BaselineShift(baselineShift interface{}) (ref *TagSvgFeOffset)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgFeOffset) Class 

func (e *TagSvgFeOffset) Class(class string) (ref *TagSvgFeOffset)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgFeOffset) ClipPath 

func (e *TagSvgFeOffset) ClipPath(clipPath string) (ref *TagSvgFeOffset)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgFeOffset) ClipRule 

func (e *TagSvgFeOffset) ClipRule(value interface{}) (ref *TagSvgFeOffset)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgFeOffset) Color 

func (e *TagSvgFeOffset) Color(value interface{}) (ref *TagSvgFeOffset)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgFeOffset) ColorInterpolation 

func (e *TagSvgFeOffset) ColorInterpolation(value interface{}) (ref *TagSvgFeOffset)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgFeOffset) ColorInterpolationFilters 

func (e *TagSvgFeOffset) ColorInterpolationFilters(value interface{}) (ref *TagSvgFeOffset)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgFeOffset) CreateElement 

func (e *TagSvgFeOffset) CreateElement() (ref *TagSvgFeOffset)

func (*TagSvgFeOffset) Cursor 

func (e *TagSvgFeOffset) Cursor(cursor SvgCursor) (ref *TagSvgFeOffset)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgFeOffset) Direction 

func (e *TagSvgFeOffset) Direction(direction SvgDirection) (ref *TagSvgFeOffset)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgFeOffset) Display 

func (e *TagSvgFeOffset) Display(value interface{}) (ref *TagSvgFeOffset)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgFeOffset) DominantBaseline 

func (e *TagSvgFeOffset) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgFeOffset)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgFeOffset) Dx 

func (e *TagSvgFeOffset) Dx(value interface{}) (ref *TagSvgFeOffset)

Dx

English: 

The dx attribute indicates a shift along the x-axis on the position of an element or its content.

 Input:
   dx: indicates a shift along the x-axis on the position of an element or its content.
     []float32: []float64{0.0, 0.1} = "0% 10%"
     []float64: []float64{0.0, 10.0} = "0 10"
     float32: 0.1 = "10%"
     float64: 10.0 = "10"
     any other type: interface{}

Portuguese 

O atributo dx indica um deslocamento ao longo do eixo x na posição de um elemento ou seu conteúdo.

 Entrada:
   dx: indica um deslocamento ao longo do eixo x na posição de um elemento ou seu conteúdo.
     []float32: []float64{0.0, 0.1} = "0% 10%"
     []float64: []float64{0.0, 10.0} = "0 10"
     float32: 0.1 = "10%"
     float64: 10.0 = "10"
     qualquer outro tipo: interface{}

func (*TagSvgFeOffset) Dy 

func (e *TagSvgFeOffset) Dy(value interface{}) (ref *TagSvgFeOffset)

Dy

English: 

The dy attribute indicates a shift along the y-axis on the position of an element or its content.

 Input:
   dy: indicates a shift along the y-axis on the position of an element or its content.
     []float32: []float64{0.0, 0.1} = "0% 10%"
     []float64: []float64{0.0, 10.0} = "0 10"
     float32: 0.1 = "10%"
     float64: 10.0 = "10"
     any other type: interface{}

Portuguese 

O atributo dy indica um deslocamento ao longo do eixo y na posição de um elemento ou seu conteúdo.

 Entrada:
   dy: indica um deslocamento ao longo do eixo y na posição de um elemento ou seu conteúdo.
     []float32: []float64{0.0, 0.1} = "0% 10%"
     []float64: []float64{0.0, 10.0} = "0 10"
     float32: 0.1 = "10%"
     float64: 10.0 = "10"
     qualquer outro tipo: interface{}

func (*TagSvgFeOffset) Fill 

func (e *TagSvgFeOffset) Fill(value interface{}) (ref *TagSvgFeOffset)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgFeOffset) FillOpacity 

func (e *TagSvgFeOffset) FillOpacity(value interface{}) (ref *TagSvgFeOffset)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgFeOffset) FillRule 

func (e *TagSvgFeOffset) FillRule(fillRule SvgFillRule) (ref *TagSvgFeOffset)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgFeOffset) Filter 

func (e *TagSvgFeOffset) Filter(filter string) (ref *TagSvgFeOffset)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgFeOffset) FloodColor 

func (e *TagSvgFeOffset) FloodColor(floodColor interface{}) (ref *TagSvgFeOffset)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgFeOffset) FloodOpacity 

func (e *TagSvgFeOffset) FloodOpacity(floodOpacity float64) (ref *TagSvgFeOffset)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgFeOffset) FontFamily 

func (e *TagSvgFeOffset) FontFamily(fontFamily string) (ref *TagSvgFeOffset)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgFeOffset) FontSize 

func (e *TagSvgFeOffset) FontSize(fontSize interface{}) (ref *TagSvgFeOffset)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgFeOffset) FontSizeAdjust 

func (e *TagSvgFeOffset) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgFeOffset)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgFeOffset) FontStretch 

func (e *TagSvgFeOffset) FontStretch(fontStretch interface{}) (ref *TagSvgFeOffset)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgFeOffset) FontStyle 

func (e *TagSvgFeOffset) FontStyle(fontStyle FontStyleRule) (ref *TagSvgFeOffset)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgFeOffset) FontVariant 

func (e *TagSvgFeOffset) FontVariant(value interface{}) (ref *TagSvgFeOffset)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgFeOffset) FontWeight 

func (e *TagSvgFeOffset) FontWeight(value interface{}) (ref *TagSvgFeOffset)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgFeOffset) Get 

func (e *TagSvgFeOffset) Get() (el js.Value)

func (*TagSvgFeOffset) Height 

func (e *TagSvgFeOffset) Height(height interface{}) (ref *TagSvgFeOffset)

Height

English: 

The height attribute defines the vertical length of an element in the user coordinate system.
     float32: 1.0 = "100%"
     any other type: interface{}

Português: 

O atributo height define o comprimento vertical de um elemento no sistema de coordenadas do usuário.
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

func (*TagSvgFeOffset) Html 

func (e *TagSvgFeOffset) Html(value string) (ref *TagSvgFeOffset)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgFeOffset) Id 

func (e *TagSvgFeOffset) Id(id string) (ref *TagSvgFeOffset)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgFeOffset) ImageRendering 

func (e *TagSvgFeOffset) ImageRendering(imageRendering string) (ref *TagSvgFeOffset)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgFeOffset) In 

func (e *TagSvgFeOffset) In(in interface{}) (ref *TagSvgFeOffset)

In

English: 

The in attribute identifies input for the given filter primitive.

 Input:
   in: identifies input for the given filter primitive.
     KSvgIn... (e.g. KSvgInSourceAlpha)
     any other type: interface{}

The value can be either one of the six keywords defined below, or a string which matches a previous result attribute value within the same <filter> element. If no value is provided and this is the first filter primitive, then this filter primitive will use SourceGraphic as its input. If no value is provided and this is a subsequent filter primitive, then this filter primitive will use the result from the previous filter primitive as its input.

If the value for result appears multiple times within a given <filter> element, then a reference to that result will use the closest preceding filter primitive with the given value for attribute result.

Portuguese 

O atributo in identifica à entrada para a primitiva de filtro fornecida.

 Entrada:
   in: identifica à entrada para a primitiva de filtro fornecida.
     KSvgIn... (e.g. KSvgInSourceAlpha)
     qualquer outro tipo: interface{}

O valor pode ser uma das seis palavras-chave definidas abaixo ou uma string que corresponda a um valor de atributo de resultado anterior dentro do mesmo elemento <filter>. Se nenhum valor for fornecido e esta for a primeira primitiva de filtro, essa primitiva de filtro usará SourceGraphic como sua entrada. Se nenhum valor for fornecido e esta for uma primitiva de filtro subsequente, essa primitiva de filtro usará o resultado da primitiva de filtro anterior como sua entrada.

Se o valor do resultado aparecer várias vezes em um determinado elemento <filter>, uma referência à esse resultado usará a primitiva de filtro anterior mais próxima com o valor fornecido para o resultado do atributo.

func (*TagSvgFeOffset) Init 

func (e *TagSvgFeOffset) Init() (ref *TagSvgFeOffset)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgFeOffset) Lang 

func (e *TagSvgFeOffset) Lang(value interface{}) (ref *TagSvgFeOffset)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgFeOffset) LetterSpacing 

func (e *TagSvgFeOffset) LetterSpacing(value float64) (ref *TagSvgFeOffset)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgFeOffset) LightingColor 

func (e *TagSvgFeOffset) LightingColor(value interface{}) (ref *TagSvgFeOffset)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgFeOffset) MarkerEnd 

func (e *TagSvgFeOffset) MarkerEnd(value interface{}) (ref *TagSvgFeOffset)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgFeOffset) MarkerMid 

func (e *TagSvgFeOffset) MarkerMid(value interface{}) (ref *TagSvgFeOffset)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgFeOffset) MarkerStart 

func (e *TagSvgFeOffset) MarkerStart(value interface{}) (ref *TagSvgFeOffset)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgFeOffset) Mask 

func (e *TagSvgFeOffset) Mask(value interface{}) (ref *TagSvgFeOffset)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgFeOffset) Opacity 

func (e *TagSvgFeOffset) Opacity(value interface{}) (ref *TagSvgFeOffset)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgFeOffset) Overflow 

func (e *TagSvgFeOffset) Overflow(value interface{}) (ref *TagSvgFeOffset)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgFeOffset) PointerEvents 

func (e *TagSvgFeOffset) PointerEvents(value interface{}) (ref *TagSvgFeOffset)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgFeOffset) Result 

func (e *TagSvgFeOffset) Result(value interface{}) (ref *TagSvgFeOffset)

Result

English:

The result attribute defines the assigned name for this filter primitive. If supplied, then graphics that result from processing this filter primitive can be referenced by an in attribute on a subsequent filter primitive within the same <filter> element. If no value is provided, the output will only be available for re-use as the implicit input into the next filter primitive if that filter primitive provides no value for its in attribute.

Português:

O atributo result define o nome atribuído para esta primitiva de filtro. Se fornecido, os gráficos resultantes do processamento dessa primitiva de filtro podem ser referenciados por um atributo in em uma primitiva de filtro subsequente dentro do mesmo elemento <filter>. Se nenhum valor for fornecido, a saída só estará disponível para reutilização como entrada implícita na próxima primitiva de filtro se essa primitiva de filtro não fornecer valor para seu atributo in.

func (*TagSvgFeOffset) ShapeRendering 

func (e *TagSvgFeOffset) ShapeRendering(value interface{}) (ref *TagSvgFeOffset)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgFeOffset) StopColor 

func (e *TagSvgFeOffset) StopColor(value interface{}) (ref *TagSvgFeOffset)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgFeOffset) StopOpacity 

func (e *TagSvgFeOffset) StopOpacity(value interface{}) (ref *TagSvgFeOffset)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgFeOffset) Stroke 

func (e *TagSvgFeOffset) Stroke(value interface{}) (ref *TagSvgFeOffset)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgFeOffset) StrokeDasharray 

func (e *TagSvgFeOffset) StrokeDasharray(value interface{}) (ref *TagSvgFeOffset)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgFeOffset) StrokeLineCap 

func (e *TagSvgFeOffset) StrokeLineCap(value interface{}) (ref *TagSvgFeOffset)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgFeOffset) StrokeLineJoin 

func (e *TagSvgFeOffset) StrokeLineJoin(value interface{}) (ref *TagSvgFeOffset)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgFeOffset) StrokeMiterLimit 

func (e *TagSvgFeOffset) StrokeMiterLimit(value float64) (ref *TagSvgFeOffset)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgFeOffset) StrokeOpacity 

func (e *TagSvgFeOffset) StrokeOpacity(value interface{}) (ref *TagSvgFeOffset)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgFeOffset) StrokeWidth 

func (e *TagSvgFeOffset) StrokeWidth(value interface{}) (ref *TagSvgFeOffset)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeOffset) Style 

func (e *TagSvgFeOffset) Style(value string) (ref *TagSvgFeOffset)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgFeOffset) Tabindex 

func (e *TagSvgFeOffset) Tabindex(value int) (ref *TagSvgFeOffset)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgFeOffset) Text 

func (e *TagSvgFeOffset) Text(value string) (ref *TagSvgFeOffset)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgFeOffset) TextAnchor 

func (e *TagSvgFeOffset) TextAnchor(value interface{}) (ref *TagSvgFeOffset)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgFeOffset) TextDecoration 

func (e *TagSvgFeOffset) TextDecoration(value interface{}) (ref *TagSvgFeOffset)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgFeOffset) TextRendering 

func (e *TagSvgFeOffset) TextRendering(value interface{}) (ref *TagSvgFeOffset)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgFeOffset) Transform 

func (e *TagSvgFeOffset) Transform(value interface{}) (ref *TagSvgFeOffset)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgFeOffset) UnicodeBidi 

func (e *TagSvgFeOffset) UnicodeBidi(value interface{}) (ref *TagSvgFeOffset)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgFeOffset) VectorEffect 

func (e *TagSvgFeOffset) VectorEffect(value interface{}) (ref *TagSvgFeOffset)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgFeOffset) Visibility 

func (e *TagSvgFeOffset) Visibility(value interface{}) (ref *TagSvgFeOffset)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgFeOffset) Width 

func (e *TagSvgFeOffset) Width(value interface{}) (ref *TagSvgFeOffset)

Width

English:

The width attribute defines the horizontal length of an element in the user coordinate system. 

Input:
  value: the horizontal length of an element
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo largura define o comprimento horizontal de um elemento no sistema de coordenadas do usuário. 

Entrada:
  value: o comprimento horizontal de um elemento
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeOffset) WordSpacing 

func (e *TagSvgFeOffset) WordSpacing(value interface{}) (ref *TagSvgFeOffset)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgFeOffset) WritingMode 

func (e *TagSvgFeOffset) WritingMode(value interface{}) (ref *TagSvgFeOffset)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgFeOffset) X 

func (e *TagSvgFeOffset) X(value interface{}) (ref *TagSvgFeOffset)

X

English:

The x attribute defines an x-axis coordinate in the user coordinate system. 

Input:
  value: defines an x-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo x define uma coordenada do eixo x no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo x
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgFeOffset) XmlLang 

func (e *TagSvgFeOffset) XmlLang(value interface{}) (ref *TagSvgFeOffset)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

func (*TagSvgFeOffset) Y 

func (e *TagSvgFeOffset) Y(value interface{}) (ref *TagSvgFeOffset)

Y

English:

The y attribute defines an y-axis coordinate in the user coordinate system. 

Input:
  value: defines an y-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo y define uma coordenada do eixo y no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo y
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

type TagSvgFePointLight 

type TagSvgFePointLight struct {
	// contains filtered or unexported fields
}

TagSvgFePointLight

English:

The <fePointLight> filter primitive defines a light source which allows to create a point light effect. It that can be used within a lighting filter primitive: <feDiffuseLighting> or <feSpecularLighting>.

Português:

A primitiva de filtro <fePointLight> define uma fonte de luz que permite criar um efeito de luz pontual. Ele que pode ser usado dentro de uma primitiva de filtro de iluminação: <feDiffuseLighting> ou <feSpecularLighting>.

func (*TagSvgFePointLight) Append 

func (e *TagSvgFePointLight) Append(elements ...Compatible) (ref *TagSvgFePointLight)

func (*TagSvgFePointLight) AppendById 

func (e *TagSvgFePointLight) AppendById(appendId string) (ref *TagSvgFePointLight)

func (*TagSvgFePointLight) AppendToElement 

func (e *TagSvgFePointLight) AppendToElement(el js.Value) (ref *TagSvgFePointLight)

func (*TagSvgFePointLight) AppendToStage 

func (e *TagSvgFePointLight) AppendToStage() (ref *TagSvgFePointLight)

func (*TagSvgFePointLight) CreateElement 

func (e *TagSvgFePointLight) CreateElement() (ref *TagSvgFePointLight)

func (*TagSvgFePointLight) Get 

func (e *TagSvgFePointLight) Get() (el js.Value)

func (*TagSvgFePointLight) Html 

func (e *TagSvgFePointLight) Html(value string) (ref *TagSvgFePointLight)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgFePointLight) Id 

func (e *TagSvgFePointLight) Id(id string) (ref *TagSvgFePointLight)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgFePointLight) Init 

func (e *TagSvgFePointLight) Init() (ref *TagSvgFePointLight)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgFePointLight) Lang 

func (e *TagSvgFePointLight) Lang(value interface{}) (ref *TagSvgFePointLight)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgFePointLight) Tabindex 

func (e *TagSvgFePointLight) Tabindex(value int) (ref *TagSvgFePointLight)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgFePointLight) Text 

func (e *TagSvgFePointLight) Text(value string) (ref *TagSvgFePointLight)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgFePointLight) X 

func (e *TagSvgFePointLight) X(value interface{}) (ref *TagSvgFePointLight)

X

English:

The x attribute defines an x-axis coordinate in the user coordinate system. 

Input:
  value: defines an x-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo x define uma coordenada do eixo x no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo x
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgFePointLight) XmlLang 

func (e *TagSvgFePointLight) XmlLang(value interface{}) (ref *TagSvgFePointLight)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

func (*TagSvgFePointLight) Y 

func (e *TagSvgFePointLight) Y(value interface{}) (ref *TagSvgFePointLight)

Y

English:

The y attribute defines an y-axis coordinate in the user coordinate system. 

Input:
  value: defines an y-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo y define uma coordenada do eixo y no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo y
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgFePointLight) Z 

func (e *TagSvgFePointLight) Z(value interface{}) (ref *TagSvgFePointLight)

Z

English:

The z attribute defines the location along the z-axis for a light source in the coordinate system established by the primitiveUnits attribute on the <filter> element, assuming that, in the initial coordinate system, the positive z-axis comes out towards the person viewing the content and assuming that one unit along the z-axis equals one unit in x and y.

Português:

O atributo z define a localização ao longo do eixo z para uma fonte de luz no sistema de coordenadas estabelecido pelo atributo primitivoUnits no elemento <filter>, assumindo que, no sistema de coordenadas inicial, o eixo z positivo sai em direção à pessoa visualizar o conteúdo e assumir que uma unidade ao longo do eixo z é igual a uma unidade em x e y.

type TagSvgFeSpecularLighting 

type TagSvgFeSpecularLighting struct {
	// contains filtered or unexported fields
}

TagSvgFeSpecularLighting

English:

The <feSpecularLighting> SVG filter primitive lights a source graphic using the alpha channel as a bump map. The resulting image is an RGBA image based on the light color. The lighting calculation follows the standard specular component of the Phong lighting model. The resulting image depends on the light color, light position and surface geometry of the input bump map. The result of the lighting calculation is added. The filter primitive assumes that the viewer is at infinity in the z direction.

This filter primitive produces an image which contains the specular reflection part of the lighting calculation. Such a map is intended to be combined with a texture using the add term of the arithmetic <feComposite> method. Multiple light sources can be simulated by adding several of these light maps before applying it to the texture image.

Português:

A primitiva de filtro SVG <feSpecularLighting> ilumina um gráfico de origem usando o canal alfa como um mapa de relevo. A imagem resultante é uma imagem RGBA baseada na cor clara. O cálculo da iluminação segue o componente especular padrão do modelo de iluminação Phong. A imagem resultante depende da cor da luz, posição da luz e geometria da superfície do mapa de relevo de entrada. O resultado do cálculo de iluminação é adicionado. A primitiva de filtro assume que o visualizador está no infinito na direção z.

Esta primitiva de filtro produz uma imagem que contém a parte de reflexão especular do cálculo de iluminação. Tal mapa deve ser combinado com uma textura usando o termo add do método aritmético <feComposite>. Várias fontes de luz podem ser simuladas adicionando vários desses mapas de luz antes de aplicá-los à imagem de textura.

func (*TagSvgFeSpecularLighting) Append 

func (e *TagSvgFeSpecularLighting) Append(elements ...Compatible) (ref *TagSvgFeSpecularLighting)

func (*TagSvgFeSpecularLighting) AppendById 

func (e *TagSvgFeSpecularLighting) AppendById(appendId string) (ref *TagSvgFeSpecularLighting)

func (*TagSvgFeSpecularLighting) AppendToElement 

func (e *TagSvgFeSpecularLighting) AppendToElement(el js.Value) (ref *TagSvgFeSpecularLighting)

func (*TagSvgFeSpecularLighting) AppendToStage 

func (e *TagSvgFeSpecularLighting) AppendToStage() (ref *TagSvgFeSpecularLighting)

func (*TagSvgFeSpecularLighting) BaselineShift 

func (e *TagSvgFeSpecularLighting) BaselineShift(baselineShift interface{}) (ref *TagSvgFeSpecularLighting)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgFeSpecularLighting) Class 

func (e *TagSvgFeSpecularLighting) Class(class string) (ref *TagSvgFeSpecularLighting)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgFeSpecularLighting) ClipPath 

func (e *TagSvgFeSpecularLighting) ClipPath(clipPath string) (ref *TagSvgFeSpecularLighting)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgFeSpecularLighting) ClipRule 

func (e *TagSvgFeSpecularLighting) ClipRule(value interface{}) (ref *TagSvgFeSpecularLighting)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgFeSpecularLighting) Color 

func (e *TagSvgFeSpecularLighting) Color(value interface{}) (ref *TagSvgFeSpecularLighting)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgFeSpecularLighting) ColorInterpolation 

func (e *TagSvgFeSpecularLighting) ColorInterpolation(value interface{}) (ref *TagSvgFeSpecularLighting)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgFeSpecularLighting) ColorInterpolationFilters 

func (e *TagSvgFeSpecularLighting) ColorInterpolationFilters(value interface{}) (ref *TagSvgFeSpecularLighting)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgFeSpecularLighting) CreateElement 

func (e *TagSvgFeSpecularLighting) CreateElement() (ref *TagSvgFeSpecularLighting)

func (*TagSvgFeSpecularLighting) Cursor 

func (e *TagSvgFeSpecularLighting) Cursor(cursor SvgCursor) (ref *TagSvgFeSpecularLighting)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgFeSpecularLighting) Direction 

func (e *TagSvgFeSpecularLighting) Direction(direction SvgDirection) (ref *TagSvgFeSpecularLighting)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgFeSpecularLighting) Display 

func (e *TagSvgFeSpecularLighting) Display(value interface{}) (ref *TagSvgFeSpecularLighting)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgFeSpecularLighting) DominantBaseline 

func (e *TagSvgFeSpecularLighting) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgFeSpecularLighting)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgFeSpecularLighting) Fill 

func (e *TagSvgFeSpecularLighting) Fill(value interface{}) (ref *TagSvgFeSpecularLighting)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgFeSpecularLighting) FillOpacity 

func (e *TagSvgFeSpecularLighting) FillOpacity(value interface{}) (ref *TagSvgFeSpecularLighting)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgFeSpecularLighting) FillRule 

func (e *TagSvgFeSpecularLighting) FillRule(fillRule SvgFillRule) (ref *TagSvgFeSpecularLighting)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgFeSpecularLighting) Filter 

func (e *TagSvgFeSpecularLighting) Filter(filter string) (ref *TagSvgFeSpecularLighting)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgFeSpecularLighting) FloodColor 

func (e *TagSvgFeSpecularLighting) FloodColor(floodColor interface{}) (ref *TagSvgFeSpecularLighting)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgFeSpecularLighting) FloodOpacity 

func (e *TagSvgFeSpecularLighting) FloodOpacity(floodOpacity float64) (ref *TagSvgFeSpecularLighting)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgFeSpecularLighting) FontFamily 

func (e *TagSvgFeSpecularLighting) FontFamily(fontFamily string) (ref *TagSvgFeSpecularLighting)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgFeSpecularLighting) FontSize 

func (e *TagSvgFeSpecularLighting) FontSize(fontSize interface{}) (ref *TagSvgFeSpecularLighting)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgFeSpecularLighting) FontSizeAdjust 

func (e *TagSvgFeSpecularLighting) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgFeSpecularLighting)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgFeSpecularLighting) FontStretch 

func (e *TagSvgFeSpecularLighting) FontStretch(fontStretch interface{}) (ref *TagSvgFeSpecularLighting)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgFeSpecularLighting) FontStyle 

func (e *TagSvgFeSpecularLighting) FontStyle(fontStyle FontStyleRule) (ref *TagSvgFeSpecularLighting)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgFeSpecularLighting) FontVariant 

func (e *TagSvgFeSpecularLighting) FontVariant(value interface{}) (ref *TagSvgFeSpecularLighting)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgFeSpecularLighting) FontWeight 

func (e *TagSvgFeSpecularLighting) FontWeight(value interface{}) (ref *TagSvgFeSpecularLighting)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgFeSpecularLighting) Get 

func (e *TagSvgFeSpecularLighting) Get() (el js.Value)

func (*TagSvgFeSpecularLighting) Height 

func (e *TagSvgFeSpecularLighting) Height(height interface{}) (ref *TagSvgFeSpecularLighting)

Height

English: 

The height attribute defines the vertical length of an element in the user coordinate system.
     float32: 1.0 = "100%"
     any other type: interface{}

Português: 

O atributo height define o comprimento vertical de um elemento no sistema de coordenadas do usuário.
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

func (*TagSvgFeSpecularLighting) Html 

func (e *TagSvgFeSpecularLighting) Html(value string) (ref *TagSvgFeSpecularLighting)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgFeSpecularLighting) Id 

func (e *TagSvgFeSpecularLighting) Id(id string) (ref *TagSvgFeSpecularLighting)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgFeSpecularLighting) ImageRendering 

func (e *TagSvgFeSpecularLighting) ImageRendering(imageRendering string) (ref *TagSvgFeSpecularLighting)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgFeSpecularLighting) In 

func (e *TagSvgFeSpecularLighting) In(in interface{}) (ref *TagSvgFeSpecularLighting)

In

English: 

The in attribute identifies input for the given filter primitive.

 Input:
   in: identifies input for the given filter primitive.
     KSvgIn... (e.g. KSvgInSourceAlpha)
     any other type: interface{}

The value can be either one of the six keywords defined below, or a string which matches a previous result attribute value within the same <filter> element. If no value is provided and this is the first filter primitive, then this filter primitive will use SourceGraphic as its input. If no value is provided and this is a subsequent filter primitive, then this filter primitive will use the result from the previous filter primitive as its input.

If the value for result appears multiple times within a given <filter> element, then a reference to that result will use the closest preceding filter primitive with the given value for attribute result.

Portuguese 

O atributo in identifica à entrada para a primitiva de filtro fornecida.

 Entrada:
   in: identifica à entrada para a primitiva de filtro fornecida.
     KSvgIn... (e.g. KSvgInSourceAlpha)
     qualquer outro tipo: interface{}

O valor pode ser uma das seis palavras-chave definidas abaixo ou uma string que corresponda a um valor de atributo de resultado anterior dentro do mesmo elemento <filter>. Se nenhum valor for fornecido e esta for a primeira primitiva de filtro, essa primitiva de filtro usará SourceGraphic como sua entrada. Se nenhum valor for fornecido e esta for uma primitiva de filtro subsequente, essa primitiva de filtro usará o resultado da primitiva de filtro anterior como sua entrada.

Se o valor do resultado aparecer várias vezes em um determinado elemento <filter>, uma referência à esse resultado usará a primitiva de filtro anterior mais próxima com o valor fornecido para o resultado do atributo.

func (*TagSvgFeSpecularLighting) Init 

func (e *TagSvgFeSpecularLighting) Init() (ref *TagSvgFeSpecularLighting)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgFeSpecularLighting) Lang 

func (e *TagSvgFeSpecularLighting) Lang(value interface{}) (ref *TagSvgFeSpecularLighting)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgFeSpecularLighting) LetterSpacing 

func (e *TagSvgFeSpecularLighting) LetterSpacing(value float64) (ref *TagSvgFeSpecularLighting)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgFeSpecularLighting) LightingColor 

func (e *TagSvgFeSpecularLighting) LightingColor(value interface{}) (ref *TagSvgFeSpecularLighting)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgFeSpecularLighting) MarkerEnd 

func (e *TagSvgFeSpecularLighting) MarkerEnd(value interface{}) (ref *TagSvgFeSpecularLighting)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgFeSpecularLighting) MarkerMid 

func (e *TagSvgFeSpecularLighting) MarkerMid(value interface{}) (ref *TagSvgFeSpecularLighting)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgFeSpecularLighting) MarkerStart 

func (e *TagSvgFeSpecularLighting) MarkerStart(value interface{}) (ref *TagSvgFeSpecularLighting)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgFeSpecularLighting) Mask 

func (e *TagSvgFeSpecularLighting) Mask(value interface{}) (ref *TagSvgFeSpecularLighting)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgFeSpecularLighting) Opacity 

func (e *TagSvgFeSpecularLighting) Opacity(value interface{}) (ref *TagSvgFeSpecularLighting)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgFeSpecularLighting) Overflow 

func (e *TagSvgFeSpecularLighting) Overflow(value interface{}) (ref *TagSvgFeSpecularLighting)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgFeSpecularLighting) PointerEvents 

func (e *TagSvgFeSpecularLighting) PointerEvents(value interface{}) (ref *TagSvgFeSpecularLighting)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgFeSpecularLighting) Result 

func (e *TagSvgFeSpecularLighting) Result(value interface{}) (ref *TagSvgFeSpecularLighting)

Result

English:

The result attribute defines the assigned name for this filter primitive. If supplied, then graphics that result from processing this filter primitive can be referenced by an in attribute on a subsequent filter primitive within the same <filter> element. If no value is provided, the output will only be available for re-use as the implicit input into the next filter primitive if that filter primitive provides no value for its in attribute.

Português:

O atributo result define o nome atribuído para esta primitiva de filtro. Se fornecido, os gráficos resultantes do processamento dessa primitiva de filtro podem ser referenciados por um atributo in em uma primitiva de filtro subsequente dentro do mesmo elemento <filter>. Se nenhum valor for fornecido, a saída só estará disponível para reutilização como entrada implícita na próxima primitiva de filtro se essa primitiva de filtro não fornecer valor para seu atributo in.

func (*TagSvgFeSpecularLighting) ShapeRendering 

func (e *TagSvgFeSpecularLighting) ShapeRendering(value interface{}) (ref *TagSvgFeSpecularLighting)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgFeSpecularLighting) SpecularConstant 

func (e *TagSvgFeSpecularLighting) SpecularConstant(value float64) (ref *TagSvgFeSpecularLighting)

SpecularConstant

English:

The specularConstant attribute controls the ratio of reflection of the specular lighting. It represents the ks value in the Phong lighting model. The bigger the value the stronger the reflection.

Português:

O atributo specularConstant controla a proporção de reflexão da iluminação especular. Ele representa o valor ks no modelo de iluminação Phong. Quanto maior o valor, mais forte a reflexão.

func (*TagSvgFeSpecularLighting) SpecularExponent 

func (e *TagSvgFeSpecularLighting) SpecularExponent(value float64) (ref *TagSvgFeSpecularLighting)

SpecularExponent

English:

The specularExponent attribute controls the focus for the light source. The bigger the value the brighter the light.

Português:

O atributo specularExponent controla o foco da fonte de luz. Quanto maior o valor, mais brilhante é a luz.

func (*TagSvgFeSpecularLighting) StopColor 

func (e *TagSvgFeSpecularLighting) StopColor(value interface{}) (ref *TagSvgFeSpecularLighting)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgFeSpecularLighting) StopOpacity 

func (e *TagSvgFeSpecularLighting) StopOpacity(value interface{}) (ref *TagSvgFeSpecularLighting)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgFeSpecularLighting) Stroke 

func (e *TagSvgFeSpecularLighting) Stroke(value interface{}) (ref *TagSvgFeSpecularLighting)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgFeSpecularLighting) StrokeDasharray 

func (e *TagSvgFeSpecularLighting) StrokeDasharray(value interface{}) (ref *TagSvgFeSpecularLighting)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgFeSpecularLighting) StrokeLineCap 

func (e *TagSvgFeSpecularLighting) StrokeLineCap(value interface{}) (ref *TagSvgFeSpecularLighting)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgFeSpecularLighting) StrokeLineJoin 

func (e *TagSvgFeSpecularLighting) StrokeLineJoin(value interface{}) (ref *TagSvgFeSpecularLighting)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgFeSpecularLighting) StrokeMiterLimit 

func (e *TagSvgFeSpecularLighting) StrokeMiterLimit(value float64) (ref *TagSvgFeSpecularLighting)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgFeSpecularLighting) StrokeOpacity 

func (e *TagSvgFeSpecularLighting) StrokeOpacity(value interface{}) (ref *TagSvgFeSpecularLighting)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgFeSpecularLighting) StrokeWidth 

func (e *TagSvgFeSpecularLighting) StrokeWidth(value interface{}) (ref *TagSvgFeSpecularLighting)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeSpecularLighting) Style 

func (e *TagSvgFeSpecularLighting) Style(value string) (ref *TagSvgFeSpecularLighting)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgFeSpecularLighting) SurfaceScale 

func (e *TagSvgFeSpecularLighting) SurfaceScale(value float64) (ref *TagSvgFeSpecularLighting)

SurfaceScale

English:

The surfaceScale attribute represents the height of the surface for a light filter primitive.

Português:

O atributo surfaceScale representa a altura da superfície para uma primitiva de filtro de luz.

func (*TagSvgFeSpecularLighting) Tabindex 

func (e *TagSvgFeSpecularLighting) Tabindex(value int) (ref *TagSvgFeSpecularLighting)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgFeSpecularLighting) Text 

func (e *TagSvgFeSpecularLighting) Text(value string) (ref *TagSvgFeSpecularLighting)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgFeSpecularLighting) TextAnchor 

func (e *TagSvgFeSpecularLighting) TextAnchor(value interface{}) (ref *TagSvgFeSpecularLighting)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgFeSpecularLighting) TextDecoration 

func (e *TagSvgFeSpecularLighting) TextDecoration(value interface{}) (ref *TagSvgFeSpecularLighting)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgFeSpecularLighting) TextRendering 

func (e *TagSvgFeSpecularLighting) TextRendering(value interface{}) (ref *TagSvgFeSpecularLighting)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgFeSpecularLighting) Transform 

func (e *TagSvgFeSpecularLighting) Transform(value interface{}) (ref *TagSvgFeSpecularLighting)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgFeSpecularLighting) UnicodeBidi 

func (e *TagSvgFeSpecularLighting) UnicodeBidi(value interface{}) (ref *TagSvgFeSpecularLighting)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgFeSpecularLighting) VectorEffect 

func (e *TagSvgFeSpecularLighting) VectorEffect(value interface{}) (ref *TagSvgFeSpecularLighting)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgFeSpecularLighting) Visibility 

func (e *TagSvgFeSpecularLighting) Visibility(value interface{}) (ref *TagSvgFeSpecularLighting)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgFeSpecularLighting) Width 

func (e *TagSvgFeSpecularLighting) Width(value interface{}) (ref *TagSvgFeSpecularLighting)

Width

English:

The width attribute defines the horizontal length of an element in the user coordinate system. 

Input:
  value: the horizontal length of an element
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo largura define o comprimento horizontal de um elemento no sistema de coordenadas do usuário. 

Entrada:
  value: o comprimento horizontal de um elemento
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeSpecularLighting) WordSpacing 

func (e *TagSvgFeSpecularLighting) WordSpacing(value interface{}) (ref *TagSvgFeSpecularLighting)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgFeSpecularLighting) WritingMode 

func (e *TagSvgFeSpecularLighting) WritingMode(value interface{}) (ref *TagSvgFeSpecularLighting)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgFeSpecularLighting) X 

func (e *TagSvgFeSpecularLighting) X(value interface{}) (ref *TagSvgFeSpecularLighting)

X

English:

The x attribute defines an x-axis coordinate in the user coordinate system. 

Input:
  value: defines an x-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo x define uma coordenada do eixo x no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo x
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgFeSpecularLighting) XmlLang 

func (e *TagSvgFeSpecularLighting) XmlLang(value interface{}) (ref *TagSvgFeSpecularLighting)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

func (*TagSvgFeSpecularLighting) Y 

func (e *TagSvgFeSpecularLighting) Y(value interface{}) (ref *TagSvgFeSpecularLighting)

Y

English:

The y attribute defines an y-axis coordinate in the user coordinate system. 

Input:
  value: defines an y-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo y define uma coordenada do eixo y no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo y
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

type TagSvgFeSpotLight 

type TagSvgFeSpotLight struct {
	// contains filtered or unexported fields
}

TagSvgFeSpotLight

English:

The <feSpotLight> SVG filter primitive defines a light source that can be used to create a spotlight effect. It is used within a lighting filter primitive: <feDiffuseLighting> or <feSpecularLighting>.

Português:

A primitiva de filtro SVG <feSpotLight> define uma fonte de luz que pode ser usada para criar um efeito de spotlight. Ele é usado dentro de uma primitiva de filtro de iluminação: <feDiffeLighting> ou <feSpecularLighting>.

func (*TagSvgFeSpotLight) Append 

func (e *TagSvgFeSpotLight) Append(elements ...Compatible) (ref *TagSvgFeSpotLight)

func (*TagSvgFeSpotLight) AppendById 

func (e *TagSvgFeSpotLight) AppendById(appendId string) (ref *TagSvgFeSpotLight)

func (*TagSvgFeSpotLight) AppendToElement 

func (e *TagSvgFeSpotLight) AppendToElement(el js.Value) (ref *TagSvgFeSpotLight)

func (*TagSvgFeSpotLight) AppendToStage 

func (e *TagSvgFeSpotLight) AppendToStage() (ref *TagSvgFeSpotLight)

func (*TagSvgFeSpotLight) BaselineShift 

func (e *TagSvgFeSpotLight) BaselineShift(baselineShift interface{}) (ref *TagSvgFeSpotLight)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgFeSpotLight) Class 

func (e *TagSvgFeSpotLight) Class(class string) (ref *TagSvgFeSpotLight)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgFeSpotLight) ClipPath 

func (e *TagSvgFeSpotLight) ClipPath(clipPath string) (ref *TagSvgFeSpotLight)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgFeSpotLight) ClipRule 

func (e *TagSvgFeSpotLight) ClipRule(value interface{}) (ref *TagSvgFeSpotLight)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgFeSpotLight) Color 

func (e *TagSvgFeSpotLight) Color(value interface{}) (ref *TagSvgFeSpotLight)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgFeSpotLight) ColorInterpolation 

func (e *TagSvgFeSpotLight) ColorInterpolation(value interface{}) (ref *TagSvgFeSpotLight)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgFeSpotLight) ColorInterpolationFilters 

func (e *TagSvgFeSpotLight) ColorInterpolationFilters(value interface{}) (ref *TagSvgFeSpotLight)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgFeSpotLight) CreateElement 

func (e *TagSvgFeSpotLight) CreateElement() (ref *TagSvgFeSpotLight)

func (*TagSvgFeSpotLight) Cursor 

func (e *TagSvgFeSpotLight) Cursor(cursor SvgCursor) (ref *TagSvgFeSpotLight)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgFeSpotLight) Direction 

func (e *TagSvgFeSpotLight) Direction(direction SvgDirection) (ref *TagSvgFeSpotLight)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgFeSpotLight) Display 

func (e *TagSvgFeSpotLight) Display(value interface{}) (ref *TagSvgFeSpotLight)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgFeSpotLight) DominantBaseline 

func (e *TagSvgFeSpotLight) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgFeSpotLight)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgFeSpotLight) Fill 

func (e *TagSvgFeSpotLight) Fill(value interface{}) (ref *TagSvgFeSpotLight)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgFeSpotLight) FillOpacity 

func (e *TagSvgFeSpotLight) FillOpacity(value interface{}) (ref *TagSvgFeSpotLight)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgFeSpotLight) FillRule 

func (e *TagSvgFeSpotLight) FillRule(fillRule SvgFillRule) (ref *TagSvgFeSpotLight)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgFeSpotLight) Filter 

func (e *TagSvgFeSpotLight) Filter(filter string) (ref *TagSvgFeSpotLight)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgFeSpotLight) FloodColor 

func (e *TagSvgFeSpotLight) FloodColor(floodColor interface{}) (ref *TagSvgFeSpotLight)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgFeSpotLight) FloodOpacity 

func (e *TagSvgFeSpotLight) FloodOpacity(floodOpacity float64) (ref *TagSvgFeSpotLight)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgFeSpotLight) FontFamily 

func (e *TagSvgFeSpotLight) FontFamily(fontFamily string) (ref *TagSvgFeSpotLight)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgFeSpotLight) FontSize 

func (e *TagSvgFeSpotLight) FontSize(fontSize interface{}) (ref *TagSvgFeSpotLight)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgFeSpotLight) FontSizeAdjust 

func (e *TagSvgFeSpotLight) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgFeSpotLight)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgFeSpotLight) FontStretch 

func (e *TagSvgFeSpotLight) FontStretch(fontStretch interface{}) (ref *TagSvgFeSpotLight)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgFeSpotLight) FontStyle 

func (e *TagSvgFeSpotLight) FontStyle(fontStyle FontStyleRule) (ref *TagSvgFeSpotLight)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgFeSpotLight) FontVariant 

func (e *TagSvgFeSpotLight) FontVariant(value interface{}) (ref *TagSvgFeSpotLight)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgFeSpotLight) FontWeight 

func (e *TagSvgFeSpotLight) FontWeight(value interface{}) (ref *TagSvgFeSpotLight)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgFeSpotLight) Get 

func (e *TagSvgFeSpotLight) Get() (el js.Value)

func (*TagSvgFeSpotLight) Height 

func (e *TagSvgFeSpotLight) Height(height interface{}) (ref *TagSvgFeSpotLight)

Height

English: 

The height attribute defines the vertical length of an element in the user coordinate system.
     float32: 1.0 = "100%"
     any other type: interface{}

Português: 

O atributo height define o comprimento vertical de um elemento no sistema de coordenadas do usuário.
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

func (*TagSvgFeSpotLight) Html 

func (e *TagSvgFeSpotLight) Html(value string) (ref *TagSvgFeSpotLight)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgFeSpotLight) Id 

func (e *TagSvgFeSpotLight) Id(id string) (ref *TagSvgFeSpotLight)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgFeSpotLight) ImageRendering 

func (e *TagSvgFeSpotLight) ImageRendering(imageRendering string) (ref *TagSvgFeSpotLight)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgFeSpotLight) Init 

func (e *TagSvgFeSpotLight) Init() (ref *TagSvgFeSpotLight)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgFeSpotLight) Lang 

func (e *TagSvgFeSpotLight) Lang(value interface{}) (ref *TagSvgFeSpotLight)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgFeSpotLight) LetterSpacing 

func (e *TagSvgFeSpotLight) LetterSpacing(value float64) (ref *TagSvgFeSpotLight)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgFeSpotLight) LightingColor 

func (e *TagSvgFeSpotLight) LightingColor(value interface{}) (ref *TagSvgFeSpotLight)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgFeSpotLight) LimitingConeAngle 

func (e *TagSvgFeSpotLight) LimitingConeAngle(value float64) (ref *TagSvgFeSpotLight)

LimitingConeAngle

English:

The limitingConeAngle attribute represents the angle in degrees between the spot light axis (i.e. the axis between the light source and the point to which it is pointing at) and the spot light cone. So it defines a limiting cone which restricts the region where the light is projected. No light is projected outside the cone. 

Input:
  value: represents the angle in degrees between the spot light axis

Português:

O atributo limitConeAngle representa o ângulo em graus entre o eixo de luz spot (ou seja, o eixo entre a fonte de luz e o ponto para o qual está apontando) e o cone de luz spot. Assim, define um cone limitador que restringe a região onde a luz é projetada. Nenhuma luz é projetada fora do cone. 

Input:
  value: representa o ângulo em graus entre o eixo da luz spot

func (*TagSvgFeSpotLight) MarkerEnd 

func (e *TagSvgFeSpotLight) MarkerEnd(value interface{}) (ref *TagSvgFeSpotLight)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgFeSpotLight) MarkerMid 

func (e *TagSvgFeSpotLight) MarkerMid(value interface{}) (ref *TagSvgFeSpotLight)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgFeSpotLight) MarkerStart 

func (e *TagSvgFeSpotLight) MarkerStart(value interface{}) (ref *TagSvgFeSpotLight)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgFeSpotLight) Mask 

func (e *TagSvgFeSpotLight) Mask(value interface{}) (ref *TagSvgFeSpotLight)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgFeSpotLight) Opacity 

func (e *TagSvgFeSpotLight) Opacity(value interface{}) (ref *TagSvgFeSpotLight)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgFeSpotLight) Overflow 

func (e *TagSvgFeSpotLight) Overflow(value interface{}) (ref *TagSvgFeSpotLight)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgFeSpotLight) PointerEvents 

func (e *TagSvgFeSpotLight) PointerEvents(value interface{}) (ref *TagSvgFeSpotLight)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgFeSpotLight) PointsAtX 

func (e *TagSvgFeSpotLight) PointsAtX(value interface{}) (ref *TagSvgFeSpotLight)

PointsAtX

English:

The pointsAtX attribute represents the x location in the coordinate system established by attribute primitiveUnits on the <filter> element of the point at which the light source is pointing.

Português:

O atributo pointsAtX representa a localização x no sistema de coordenadas estabelecido pelo atributo primitivaUnits no elemento <filter> do ponto para o qual a fonte de luz está apontando.

func (*TagSvgFeSpotLight) PointsAtY 

func (e *TagSvgFeSpotLight) PointsAtY(value interface{}) (ref *TagSvgFeSpotLight)

PointsAtY

English:

The pointsAtY attribute represents the y location in the coordinate system established by attribute primitiveUnits on the <filter> element of the point at which the light source is pointing.

Português:

O atributo pointsAtY representa a localização y no sistema de coordenadas estabelecido pelo atributo primitivaUnits no elemento <filter> do ponto para o qual a fonte de luz está apontando.

func (*TagSvgFeSpotLight) PointsAtZ 

func (e *TagSvgFeSpotLight) PointsAtZ(value interface{}) (ref *TagSvgFeSpotLight)

PointsAtZ

English:

The pointsAtZ attribute represents the y location in the coordinate system established by attribute primitiveUnits on the <filter> element of the point at which the light source is pointing, assuming that, in the initial local coordinate system, the positive z-axis comes out towards the person viewing the content and assuming that one unit along the z-axis equals one unit in x and y. 

Input:
  value: represents the y location in the coordinate system
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo pointsAtZ representa a localização y no sistema de coordenadas estabelecido pelo atributo primitivaUnits no elemento <filter> do ponto em que a fonte de luz está apontando, assumindo que, no sistema de coordenadas local inicial, o eixo z positivo sai em direção a pessoa visualizando o conteúdo e assumindo que uma unidade ao longo do eixo z é igual a uma unidade em x e y. 

Input:
  value: representa a localização y no sistema de coordenadas
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeSpotLight) Result 

func (e *TagSvgFeSpotLight) Result(value interface{}) (ref *TagSvgFeSpotLight)

Result

English:

The result attribute defines the assigned name for this filter primitive. If supplied, then graphics that result from processing this filter primitive can be referenced by an in attribute on a subsequent filter primitive within the same <filter> element. If no value is provided, the output will only be available for re-use as the implicit input into the next filter primitive if that filter primitive provides no value for its in attribute.

Português:

O atributo result define o nome atribuído para esta primitiva de filtro. Se fornecido, os gráficos resultantes do processamento dessa primitiva de filtro podem ser referenciados por um atributo in em uma primitiva de filtro subsequente dentro do mesmo elemento <filter>. Se nenhum valor for fornecido, a saída só estará disponível para reutilização como entrada implícita na próxima primitiva de filtro se essa primitiva de filtro não fornecer valor para seu atributo in.

func (*TagSvgFeSpotLight) ShapeRendering 

func (e *TagSvgFeSpotLight) ShapeRendering(value interface{}) (ref *TagSvgFeSpotLight)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgFeSpotLight) SpecularExponent 

func (e *TagSvgFeSpotLight) SpecularExponent(value float64) (ref *TagSvgFeSpotLight)

SpecularExponent

English:

The specularExponent attribute controls the focus for the light source. The bigger the value the brighter the light.

Português:

O atributo specularExponent controla o foco da fonte de luz. Quanto maior o valor, mais brilhante é a luz.

func (*TagSvgFeSpotLight) StopColor 

func (e *TagSvgFeSpotLight) StopColor(value interface{}) (ref *TagSvgFeSpotLight)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgFeSpotLight) StopOpacity 

func (e *TagSvgFeSpotLight) StopOpacity(value interface{}) (ref *TagSvgFeSpotLight)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgFeSpotLight) Stroke 

func (e *TagSvgFeSpotLight) Stroke(value interface{}) (ref *TagSvgFeSpotLight)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgFeSpotLight) StrokeDasharray 

func (e *TagSvgFeSpotLight) StrokeDasharray(value interface{}) (ref *TagSvgFeSpotLight)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgFeSpotLight) StrokeLineCap 

func (e *TagSvgFeSpotLight) StrokeLineCap(value interface{}) (ref *TagSvgFeSpotLight)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgFeSpotLight) StrokeLineJoin 

func (e *TagSvgFeSpotLight) StrokeLineJoin(value interface{}) (ref *TagSvgFeSpotLight)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgFeSpotLight) StrokeMiterLimit 

func (e *TagSvgFeSpotLight) StrokeMiterLimit(value float64) (ref *TagSvgFeSpotLight)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgFeSpotLight) StrokeOpacity 

func (e *TagSvgFeSpotLight) StrokeOpacity(value interface{}) (ref *TagSvgFeSpotLight)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgFeSpotLight) StrokeWidth 

func (e *TagSvgFeSpotLight) StrokeWidth(value interface{}) (ref *TagSvgFeSpotLight)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeSpotLight) Style 

func (e *TagSvgFeSpotLight) Style(value string) (ref *TagSvgFeSpotLight)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgFeSpotLight) Tabindex 

func (e *TagSvgFeSpotLight) Tabindex(value int) (ref *TagSvgFeSpotLight)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgFeSpotLight) Text 

func (e *TagSvgFeSpotLight) Text(value string) (ref *TagSvgFeSpotLight)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgFeSpotLight) TextAnchor 

func (e *TagSvgFeSpotLight) TextAnchor(value interface{}) (ref *TagSvgFeSpotLight)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgFeSpotLight) TextDecoration 

func (e *TagSvgFeSpotLight) TextDecoration(value interface{}) (ref *TagSvgFeSpotLight)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgFeSpotLight) TextRendering 

func (e *TagSvgFeSpotLight) TextRendering(value interface{}) (ref *TagSvgFeSpotLight)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgFeSpotLight) Transform 

func (e *TagSvgFeSpotLight) Transform(value interface{}) (ref *TagSvgFeSpotLight)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgFeSpotLight) UnicodeBidi 

func (e *TagSvgFeSpotLight) UnicodeBidi(value interface{}) (ref *TagSvgFeSpotLight)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgFeSpotLight) VectorEffect 

func (e *TagSvgFeSpotLight) VectorEffect(value interface{}) (ref *TagSvgFeSpotLight)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgFeSpotLight) Visibility 

func (e *TagSvgFeSpotLight) Visibility(value interface{}) (ref *TagSvgFeSpotLight)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgFeSpotLight) Width 

func (e *TagSvgFeSpotLight) Width(value interface{}) (ref *TagSvgFeSpotLight)

Width

English:

The width attribute defines the horizontal length of an element in the user coordinate system. 

Input:
  value: the horizontal length of an element
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo largura define o comprimento horizontal de um elemento no sistema de coordenadas do usuário. 

Entrada:
  value: o comprimento horizontal de um elemento
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeSpotLight) WordSpacing 

func (e *TagSvgFeSpotLight) WordSpacing(value interface{}) (ref *TagSvgFeSpotLight)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgFeSpotLight) WritingMode 

func (e *TagSvgFeSpotLight) WritingMode(value interface{}) (ref *TagSvgFeSpotLight)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgFeSpotLight) X 

func (e *TagSvgFeSpotLight) X(value interface{}) (ref *TagSvgFeSpotLight)

X

English:

The x attribute defines an x-axis coordinate in the user coordinate system. 

Input:
  value: defines an x-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo x define uma coordenada do eixo x no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo x
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgFeSpotLight) XmlLang 

func (e *TagSvgFeSpotLight) XmlLang(value interface{}) (ref *TagSvgFeSpotLight)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

func (*TagSvgFeSpotLight) Y 

func (e *TagSvgFeSpotLight) Y(value interface{}) (ref *TagSvgFeSpotLight)

Y

English:

The y attribute defines an y-axis coordinate in the user coordinate system. 

Input:
  value: defines an y-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo y define uma coordenada do eixo y no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo y
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgFeSpotLight) Z 

func (e *TagSvgFeSpotLight) Z(value interface{}) (ref *TagSvgFeSpotLight)

Z

English:

The z attribute defines the location along the z-axis for a light source in the coordinate system established by the primitiveUnits attribute on the <filter> element, assuming that, in the initial coordinate system, the positive z-axis comes out towards the person viewing the content and assuming that one unit along the z-axis equals one unit in x and y.

Português:

O atributo z define a localização ao longo do eixo z para uma fonte de luz no sistema de coordenadas estabelecido pelo atributo primitivoUnits no elemento <filter>, assumindo que, no sistema de coordenadas inicial, o eixo z positivo sai em direção à pessoa visualizar o conteúdo e assumir que uma unidade ao longo do eixo z é igual a uma unidade em x e y.

type TagSvgFeTile 

type TagSvgFeTile struct {
	// contains filtered or unexported fields
}

TagSvgFeTile

English:

The <feTile> SVG filter primitive allows to fill a target rectangle with a repeated, tiled pattern of an input image. The effect is similar to the one of a <pattern>.

Português:

A primitiva de filtro SVG <feTile> permite preencher um retângulo de destino com um padrão repetido e lado a lado de uma imagem de entrada. O efeito é semelhante ao de um <pattern>.

func (*TagSvgFeTile) Append 

func (e *TagSvgFeTile) Append(elements ...Compatible) (ref *TagSvgFeTile)

func (*TagSvgFeTile) AppendById 

func (e *TagSvgFeTile) AppendById(appendId string) (ref *TagSvgFeTile)

func (*TagSvgFeTile) AppendToElement 

func (e *TagSvgFeTile) AppendToElement(el js.Value) (ref *TagSvgFeTile)

func (*TagSvgFeTile) AppendToStage 

func (e *TagSvgFeTile) AppendToStage() (ref *TagSvgFeTile)

func (*TagSvgFeTile) BaselineShift 

func (e *TagSvgFeTile) BaselineShift(baselineShift interface{}) (ref *TagSvgFeTile)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgFeTile) Class 

func (e *TagSvgFeTile) Class(class string) (ref *TagSvgFeTile)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgFeTile) ClipPath 

func (e *TagSvgFeTile) ClipPath(clipPath string) (ref *TagSvgFeTile)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgFeTile) ClipRule 

func (e *TagSvgFeTile) ClipRule(value interface{}) (ref *TagSvgFeTile)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgFeTile) Color 

func (e *TagSvgFeTile) Color(value interface{}) (ref *TagSvgFeTile)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgFeTile) ColorInterpolation 

func (e *TagSvgFeTile) ColorInterpolation(value interface{}) (ref *TagSvgFeTile)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgFeTile) ColorInterpolationFilters 

func (e *TagSvgFeTile) ColorInterpolationFilters(value interface{}) (ref *TagSvgFeTile)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgFeTile) CreateElement 

func (e *TagSvgFeTile) CreateElement() (ref *TagSvgFeTile)

func (*TagSvgFeTile) Cursor 

func (e *TagSvgFeTile) Cursor(cursor SvgCursor) (ref *TagSvgFeTile)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgFeTile) Direction 

func (e *TagSvgFeTile) Direction(direction SvgDirection) (ref *TagSvgFeTile)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgFeTile) Display 

func (e *TagSvgFeTile) Display(value interface{}) (ref *TagSvgFeTile)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgFeTile) DominantBaseline 

func (e *TagSvgFeTile) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgFeTile)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgFeTile) Fill 

func (e *TagSvgFeTile) Fill(value interface{}) (ref *TagSvgFeTile)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgFeTile) FillOpacity 

func (e *TagSvgFeTile) FillOpacity(value interface{}) (ref *TagSvgFeTile)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgFeTile) FillRule 

func (e *TagSvgFeTile) FillRule(fillRule SvgFillRule) (ref *TagSvgFeTile)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgFeTile) Filter 

func (e *TagSvgFeTile) Filter(filter string) (ref *TagSvgFeTile)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgFeTile) FloodColor 

func (e *TagSvgFeTile) FloodColor(floodColor interface{}) (ref *TagSvgFeTile)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgFeTile) FloodOpacity 

func (e *TagSvgFeTile) FloodOpacity(floodOpacity float64) (ref *TagSvgFeTile)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgFeTile) FontFamily 

func (e *TagSvgFeTile) FontFamily(fontFamily string) (ref *TagSvgFeTile)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgFeTile) FontSize 

func (e *TagSvgFeTile) FontSize(fontSize interface{}) (ref *TagSvgFeTile)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgFeTile) FontSizeAdjust 

func (e *TagSvgFeTile) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgFeTile)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgFeTile) FontStretch 

func (e *TagSvgFeTile) FontStretch(fontStretch interface{}) (ref *TagSvgFeTile)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgFeTile) FontStyle 

func (e *TagSvgFeTile) FontStyle(fontStyle FontStyleRule) (ref *TagSvgFeTile)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgFeTile) FontVariant 

func (e *TagSvgFeTile) FontVariant(value interface{}) (ref *TagSvgFeTile)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgFeTile) FontWeight 

func (e *TagSvgFeTile) FontWeight(value interface{}) (ref *TagSvgFeTile)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgFeTile) Get 

func (e *TagSvgFeTile) Get() (el js.Value)

func (*TagSvgFeTile) Height 

func (e *TagSvgFeTile) Height(height interface{}) (ref *TagSvgFeTile)

Height

English: 

The height attribute defines the vertical length of an element in the user coordinate system.
     float32: 1.0 = "100%"
     any other type: interface{}

Português: 

O atributo height define o comprimento vertical de um elemento no sistema de coordenadas do usuário.
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

func (*TagSvgFeTile) Html 

func (e *TagSvgFeTile) Html(value string) (ref *TagSvgFeTile)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgFeTile) Id 

func (e *TagSvgFeTile) Id(id string) (ref *TagSvgFeTile)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgFeTile) ImageRendering 

func (e *TagSvgFeTile) ImageRendering(imageRendering string) (ref *TagSvgFeTile)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgFeTile) In 

func (e *TagSvgFeTile) In(in interface{}) (ref *TagSvgFeTile)

In

English: 

The in attribute identifies input for the given filter primitive.

 Input:
   in: identifies input for the given filter primitive.
     KSvgIn... (e.g. KSvgInSourceAlpha)
     any other type: interface{}

The value can be either one of the six keywords defined below, or a string which matches a previous result attribute value within the same <filter> element. If no value is provided and this is the first filter primitive, then this filter primitive will use SourceGraphic as its input. If no value is provided and this is a subsequent filter primitive, then this filter primitive will use the result from the previous filter primitive as its input.

If the value for result appears multiple times within a given <filter> element, then a reference to that result will use the closest preceding filter primitive with the given value for attribute result.

Portuguese 

O atributo in identifica à entrada para a primitiva de filtro fornecida.

 Entrada:
   in: identifica à entrada para a primitiva de filtro fornecida.
     KSvgIn... (e.g. KSvgInSourceAlpha)
     qualquer outro tipo: interface{}

O valor pode ser uma das seis palavras-chave definidas abaixo ou uma string que corresponda a um valor de atributo de resultado anterior dentro do mesmo elemento <filter>. Se nenhum valor for fornecido e esta for a primeira primitiva de filtro, essa primitiva de filtro usará SourceGraphic como sua entrada. Se nenhum valor for fornecido e esta for uma primitiva de filtro subsequente, essa primitiva de filtro usará o resultado da primitiva de filtro anterior como sua entrada.

Se o valor do resultado aparecer várias vezes em um determinado elemento <filter>, uma referência à esse resultado usará a primitiva de filtro anterior mais próxima com o valor fornecido para o resultado do atributo.

func (*TagSvgFeTile) Init 

func (e *TagSvgFeTile) Init() (ref *TagSvgFeTile)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgFeTile) Lang 

func (e *TagSvgFeTile) Lang(value interface{}) (ref *TagSvgFeTile)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgFeTile) LetterSpacing 

func (e *TagSvgFeTile) LetterSpacing(value float64) (ref *TagSvgFeTile)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgFeTile) LightingColor 

func (e *TagSvgFeTile) LightingColor(value interface{}) (ref *TagSvgFeTile)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgFeTile) MarkerEnd 

func (e *TagSvgFeTile) MarkerEnd(value interface{}) (ref *TagSvgFeTile)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgFeTile) MarkerMid 

func (e *TagSvgFeTile) MarkerMid(value interface{}) (ref *TagSvgFeTile)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgFeTile) MarkerStart 

func (e *TagSvgFeTile) MarkerStart(value interface{}) (ref *TagSvgFeTile)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgFeTile) Mask 

func (e *TagSvgFeTile) Mask(value interface{}) (ref *TagSvgFeTile)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgFeTile) Opacity 

func (e *TagSvgFeTile) Opacity(value interface{}) (ref *TagSvgFeTile)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgFeTile) Overflow 

func (e *TagSvgFeTile) Overflow(value interface{}) (ref *TagSvgFeTile)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgFeTile) PointerEvents 

func (e *TagSvgFeTile) PointerEvents(value interface{}) (ref *TagSvgFeTile)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgFeTile) Result 

func (e *TagSvgFeTile) Result(value interface{}) (ref *TagSvgFeTile)

Result

English:

The result attribute defines the assigned name for this filter primitive. If supplied, then graphics that result from processing this filter primitive can be referenced by an in attribute on a subsequent filter primitive within the same <filter> element. If no value is provided, the output will only be available for re-use as the implicit input into the next filter primitive if that filter primitive provides no value for its in attribute.

Português:

O atributo result define o nome atribuído para esta primitiva de filtro. Se fornecido, os gráficos resultantes do processamento dessa primitiva de filtro podem ser referenciados por um atributo in em uma primitiva de filtro subsequente dentro do mesmo elemento <filter>. Se nenhum valor for fornecido, a saída só estará disponível para reutilização como entrada implícita na próxima primitiva de filtro se essa primitiva de filtro não fornecer valor para seu atributo in.

func (*TagSvgFeTile) ShapeRendering 

func (e *TagSvgFeTile) ShapeRendering(value interface{}) (ref *TagSvgFeTile)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgFeTile) StopColor 

func (e *TagSvgFeTile) StopColor(value interface{}) (ref *TagSvgFeTile)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgFeTile) StopOpacity 

func (e *TagSvgFeTile) StopOpacity(value interface{}) (ref *TagSvgFeTile)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgFeTile) Stroke 

func (e *TagSvgFeTile) Stroke(value interface{}) (ref *TagSvgFeTile)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgFeTile) StrokeDasharray 

func (e *TagSvgFeTile) StrokeDasharray(value interface{}) (ref *TagSvgFeTile)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgFeTile) StrokeLineCap 

func (e *TagSvgFeTile) StrokeLineCap(value interface{}) (ref *TagSvgFeTile)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgFeTile) StrokeLineJoin 

func (e *TagSvgFeTile) StrokeLineJoin(value interface{}) (ref *TagSvgFeTile)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgFeTile) StrokeMiterLimit 

func (e *TagSvgFeTile) StrokeMiterLimit(value float64) (ref *TagSvgFeTile)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgFeTile) StrokeOpacity 

func (e *TagSvgFeTile) StrokeOpacity(value interface{}) (ref *TagSvgFeTile)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgFeTile) StrokeWidth 

func (e *TagSvgFeTile) StrokeWidth(value interface{}) (ref *TagSvgFeTile)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeTile) Style 

func (e *TagSvgFeTile) Style(value string) (ref *TagSvgFeTile)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgFeTile) Tabindex 

func (e *TagSvgFeTile) Tabindex(value int) (ref *TagSvgFeTile)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgFeTile) Text 

func (e *TagSvgFeTile) Text(value string) (ref *TagSvgFeTile)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgFeTile) TextAnchor 

func (e *TagSvgFeTile) TextAnchor(value interface{}) (ref *TagSvgFeTile)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgFeTile) TextDecoration 

func (e *TagSvgFeTile) TextDecoration(value interface{}) (ref *TagSvgFeTile)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgFeTile) TextRendering 

func (e *TagSvgFeTile) TextRendering(value interface{}) (ref *TagSvgFeTile)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgFeTile) Transform 

func (e *TagSvgFeTile) Transform(value interface{}) (ref *TagSvgFeTile)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgFeTile) UnicodeBidi 

func (e *TagSvgFeTile) UnicodeBidi(value interface{}) (ref *TagSvgFeTile)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgFeTile) VectorEffect 

func (e *TagSvgFeTile) VectorEffect(value interface{}) (ref *TagSvgFeTile)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgFeTile) Visibility 

func (e *TagSvgFeTile) Visibility(value interface{}) (ref *TagSvgFeTile)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgFeTile) Width 

func (e *TagSvgFeTile) Width(value interface{}) (ref *TagSvgFeTile)

Width

English:

The width attribute defines the horizontal length of an element in the user coordinate system. 

Input:
  value: the horizontal length of an element
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo largura define o comprimento horizontal de um elemento no sistema de coordenadas do usuário. 

Entrada:
  value: o comprimento horizontal de um elemento
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeTile) WordSpacing 

func (e *TagSvgFeTile) WordSpacing(value interface{}) (ref *TagSvgFeTile)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgFeTile) WritingMode 

func (e *TagSvgFeTile) WritingMode(value interface{}) (ref *TagSvgFeTile)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgFeTile) X 

func (e *TagSvgFeTile) X(value interface{}) (ref *TagSvgFeTile)

X

English:

The x attribute defines an x-axis coordinate in the user coordinate system. 

Input:
  value: defines an x-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo x define uma coordenada do eixo x no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo x
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgFeTile) XmlLang 

func (e *TagSvgFeTile) XmlLang(value interface{}) (ref *TagSvgFeTile)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

func (*TagSvgFeTile) Y 

func (e *TagSvgFeTile) Y(value interface{}) (ref *TagSvgFeTile)

Y

English:

The y attribute defines an y-axis coordinate in the user coordinate system. 

Input:
  value: defines an y-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo y define uma coordenada do eixo y no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo y
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

type TagSvgFeTurbulence 

type TagSvgFeTurbulence struct {
	// contains filtered or unexported fields
}

TagSvgFeTurbulence

English:

The <feTurbulence> SVG filter primitive creates an image using the Perlin turbulence function. It allows the synthesis of artificial textures like clouds or marble. The resulting image will fill the entire filter primitive subregion.

Português:

A primitiva de filtro SVG <feTurbulence> cria uma imagem usando a função de turbulência Perlin. Permite a síntese de texturas artificiais como nuvens ou mármore. A imagem resultante preencherá toda a sub-região primitiva do filtro.

func (*TagSvgFeTurbulence) Append 

func (e *TagSvgFeTurbulence) Append(elements ...Compatible) (ref *TagSvgFeTurbulence)

func (*TagSvgFeTurbulence) AppendById 

func (e *TagSvgFeTurbulence) AppendById(appendId string) (ref *TagSvgFeTurbulence)

func (*TagSvgFeTurbulence) AppendToElement 

func (e *TagSvgFeTurbulence) AppendToElement(el js.Value) (ref *TagSvgFeTurbulence)

func (*TagSvgFeTurbulence) AppendToStage 

func (e *TagSvgFeTurbulence) AppendToStage() (ref *TagSvgFeTurbulence)

func (*TagSvgFeTurbulence) BaseFrequency 

func (e *TagSvgFeTurbulence) BaseFrequency(baseFrequency float64) (ref *TagSvgFeTurbulence)

BaseFrequency

English: 

The baseFrequency attribute represents the base frequency parameter for the noise function of the <feTurbulence> filter primitive.

 Input:
   baseFrequency: represents the base frequency parameter for the noise function

Português: 

O atributo baseFrequency representa o parâmetro de frequência base para a função de ruído da primitiva de filtro <feTurbulence>.

 Entrada:
   baseFrequency: representa o parâmetro de frequência base para a função de ruído

func (*TagSvgFeTurbulence) BaselineShift 

func (e *TagSvgFeTurbulence) BaselineShift(baselineShift interface{}) (ref *TagSvgFeTurbulence)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgFeTurbulence) Class 

func (e *TagSvgFeTurbulence) Class(class string) (ref *TagSvgFeTurbulence)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgFeTurbulence) ClipPath 

func (e *TagSvgFeTurbulence) ClipPath(clipPath string) (ref *TagSvgFeTurbulence)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgFeTurbulence) ClipRule 

func (e *TagSvgFeTurbulence) ClipRule(value interface{}) (ref *TagSvgFeTurbulence)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgFeTurbulence) Color 

func (e *TagSvgFeTurbulence) Color(value interface{}) (ref *TagSvgFeTurbulence)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgFeTurbulence) ColorInterpolation 

func (e *TagSvgFeTurbulence) ColorInterpolation(value interface{}) (ref *TagSvgFeTurbulence)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgFeTurbulence) ColorInterpolationFilters 

func (e *TagSvgFeTurbulence) ColorInterpolationFilters(value interface{}) (ref *TagSvgFeTurbulence)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgFeTurbulence) CreateElement 

func (e *TagSvgFeTurbulence) CreateElement() (ref *TagSvgFeTurbulence)

func (*TagSvgFeTurbulence) Cursor 

func (e *TagSvgFeTurbulence) Cursor(cursor SvgCursor) (ref *TagSvgFeTurbulence)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgFeTurbulence) Direction 

func (e *TagSvgFeTurbulence) Direction(direction SvgDirection) (ref *TagSvgFeTurbulence)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgFeTurbulence) Display 

func (e *TagSvgFeTurbulence) Display(value interface{}) (ref *TagSvgFeTurbulence)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgFeTurbulence) DominantBaseline 

func (e *TagSvgFeTurbulence) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgFeTurbulence)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgFeTurbulence) Fill 

func (e *TagSvgFeTurbulence) Fill(value interface{}) (ref *TagSvgFeTurbulence)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgFeTurbulence) FillOpacity 

func (e *TagSvgFeTurbulence) FillOpacity(value interface{}) (ref *TagSvgFeTurbulence)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgFeTurbulence) FillRule 

func (e *TagSvgFeTurbulence) FillRule(fillRule SvgFillRule) (ref *TagSvgFeTurbulence)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgFeTurbulence) Filter 

func (e *TagSvgFeTurbulence) Filter(filter string) (ref *TagSvgFeTurbulence)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgFeTurbulence) FloodColor 

func (e *TagSvgFeTurbulence) FloodColor(floodColor interface{}) (ref *TagSvgFeTurbulence)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgFeTurbulence) FloodOpacity 

func (e *TagSvgFeTurbulence) FloodOpacity(floodOpacity float64) (ref *TagSvgFeTurbulence)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgFeTurbulence) FontFamily 

func (e *TagSvgFeTurbulence) FontFamily(fontFamily string) (ref *TagSvgFeTurbulence)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgFeTurbulence) FontSize 

func (e *TagSvgFeTurbulence) FontSize(fontSize interface{}) (ref *TagSvgFeTurbulence)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgFeTurbulence) FontSizeAdjust 

func (e *TagSvgFeTurbulence) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgFeTurbulence)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgFeTurbulence) FontStretch 

func (e *TagSvgFeTurbulence) FontStretch(fontStretch interface{}) (ref *TagSvgFeTurbulence)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgFeTurbulence) FontStyle 

func (e *TagSvgFeTurbulence) FontStyle(fontStyle FontStyleRule) (ref *TagSvgFeTurbulence)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgFeTurbulence) FontVariant 

func (e *TagSvgFeTurbulence) FontVariant(value interface{}) (ref *TagSvgFeTurbulence)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgFeTurbulence) FontWeight 

func (e *TagSvgFeTurbulence) FontWeight(value interface{}) (ref *TagSvgFeTurbulence)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgFeTurbulence) Get 

func (e *TagSvgFeTurbulence) Get() (el js.Value)

func (*TagSvgFeTurbulence) Height 

func (e *TagSvgFeTurbulence) Height(height interface{}) (ref *TagSvgFeTurbulence)

Height

English: 

The height attribute defines the vertical length of an element in the user coordinate system.
     float32: 1.0 = "100%"
     any other type: interface{}

Português: 

O atributo height define o comprimento vertical de um elemento no sistema de coordenadas do usuário.
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

func (*TagSvgFeTurbulence) Html 

func (e *TagSvgFeTurbulence) Html(value string) (ref *TagSvgFeTurbulence)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgFeTurbulence) Id 

func (e *TagSvgFeTurbulence) Id(id string) (ref *TagSvgFeTurbulence)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgFeTurbulence) ImageRendering 

func (e *TagSvgFeTurbulence) ImageRendering(imageRendering string) (ref *TagSvgFeTurbulence)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgFeTurbulence) Init 

func (e *TagSvgFeTurbulence) Init() (ref *TagSvgFeTurbulence)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgFeTurbulence) Lang 

func (e *TagSvgFeTurbulence) Lang(value interface{}) (ref *TagSvgFeTurbulence)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgFeTurbulence) LetterSpacing 

func (e *TagSvgFeTurbulence) LetterSpacing(value float64) (ref *TagSvgFeTurbulence)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgFeTurbulence) LightingColor 

func (e *TagSvgFeTurbulence) LightingColor(value interface{}) (ref *TagSvgFeTurbulence)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgFeTurbulence) MarkerEnd 

func (e *TagSvgFeTurbulence) MarkerEnd(value interface{}) (ref *TagSvgFeTurbulence)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgFeTurbulence) MarkerMid 

func (e *TagSvgFeTurbulence) MarkerMid(value interface{}) (ref *TagSvgFeTurbulence)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgFeTurbulence) MarkerStart 

func (e *TagSvgFeTurbulence) MarkerStart(value interface{}) (ref *TagSvgFeTurbulence)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgFeTurbulence) Mask 

func (e *TagSvgFeTurbulence) Mask(value interface{}) (ref *TagSvgFeTurbulence)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgFeTurbulence) NumOctaves 

func (e *TagSvgFeTurbulence) NumOctaves(value float64) (ref *TagSvgFeTurbulence)

NumOctaves

English:

The numOctaves attribute defines the number of octaves for the noise function of the <feTurbulence> primitive. 

Input:
  value: defines the number of octaves for the noise function

An octave is a noise function defined by its frequency and amplitude. A turbulence is built by accumulating several octaves with increasing frequencies and decreasing amplitudes. The higher the number of octaves, the more natural the noise looks. Though more octaves also require more calculations, resulting in a negative impact on performance.

Português:

O atributo numOctaves define o número de oitavas para a função de ruído da primitiva <feTurbulence>. 

Input:
  value: define o número de oitavas para a função de ruído

Uma oitava é uma função de ruído definida por sua frequência e amplitude. Uma turbulência é construída acumulando várias oitavas com frequências crescentes e amplitudes decrescentes. Quanto maior o número de oitavas, mais natural o ruído parece. Embora mais oitavas também exijam mais cálculos, resultando em um impacto negativo no desempenho.

func (*TagSvgFeTurbulence) Opacity 

func (e *TagSvgFeTurbulence) Opacity(value interface{}) (ref *TagSvgFeTurbulence)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgFeTurbulence) Overflow 

func (e *TagSvgFeTurbulence) Overflow(value interface{}) (ref *TagSvgFeTurbulence)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgFeTurbulence) PointerEvents 

func (e *TagSvgFeTurbulence) PointerEvents(value interface{}) (ref *TagSvgFeTurbulence)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgFeTurbulence) Result 

func (e *TagSvgFeTurbulence) Result(value interface{}) (ref *TagSvgFeTurbulence)

Result

English:

The result attribute defines the assigned name for this filter primitive. If supplied, then graphics that result from processing this filter primitive can be referenced by an in attribute on a subsequent filter primitive within the same <filter> element. If no value is provided, the output will only be available for re-use as the implicit input into the next filter primitive if that filter primitive provides no value for its in attribute.

Português:

O atributo result define o nome atribuído para esta primitiva de filtro. Se fornecido, os gráficos resultantes do processamento dessa primitiva de filtro podem ser referenciados por um atributo in em uma primitiva de filtro subsequente dentro do mesmo elemento <filter>. Se nenhum valor for fornecido, a saída só estará disponível para reutilização como entrada implícita na próxima primitiva de filtro se essa primitiva de filtro não fornecer valor para seu atributo in.

func (*TagSvgFeTurbulence) Seed 

func (e *TagSvgFeTurbulence) Seed(value float64) (ref *TagSvgFeTurbulence)

Seed

English:

The seed attribute represents the starting number for the pseudo random number generator of the <feTurbulence> filter primitive.

Português:

O atributo seed representa o número inicial para o gerador de números pseudo aleatórios da primitiva de filtro <feTurbulence>.

func (*TagSvgFeTurbulence) ShapeRendering 

func (e *TagSvgFeTurbulence) ShapeRendering(value interface{}) (ref *TagSvgFeTurbulence)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgFeTurbulence) StdDeviation 

func (e *TagSvgFeTurbulence) StdDeviation(value interface{}) (ref *TagSvgFeTurbulence)

StdDeviation

English:

The stdDeviation attribute defines the standard deviation for the blur operation. 

Input:
  value: defines the standard deviation
    []float64: []float64{2,5} = "2 5"
    any other type: interface{}

Português:

O atributo stdDeviation define o desvio padrão para a operação de desfoque. 

Input:
  value: define o desvio padrão
    []float64: []float64{2,5} = "2 5"
    qualquer outro tipo: interface{}

func (*TagSvgFeTurbulence) StitchTiles 

func (e *TagSvgFeTurbulence) StitchTiles(value interface{}) (ref *TagSvgFeTurbulence)

StitchTiles

English:

The stitchTiles attribute defines how the Perlin Noise tiles behave at the border. 

Input:
  value: defines how the Perlin Noise tiles behave at the border
    const: KSvgStitchTiles... (e.g. KSvgStitchTilesNoStitch)
    any other type: interface{}

Português:

O atributo stitchTiles define como os blocos Perlin Noise se comportam na borda. 

Entrada:
  value: define como os blocos Perlin Noise se comportam na borda
    const: KSvgStitchTiles... (ex. KSvgStitchTilesNoStitch)
    qualquer outro tipo: interface{}

func (*TagSvgFeTurbulence) StopColor 

func (e *TagSvgFeTurbulence) StopColor(value interface{}) (ref *TagSvgFeTurbulence)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgFeTurbulence) StopOpacity 

func (e *TagSvgFeTurbulence) StopOpacity(value interface{}) (ref *TagSvgFeTurbulence)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgFeTurbulence) Stroke 

func (e *TagSvgFeTurbulence) Stroke(value interface{}) (ref *TagSvgFeTurbulence)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgFeTurbulence) StrokeDasharray 

func (e *TagSvgFeTurbulence) StrokeDasharray(value interface{}) (ref *TagSvgFeTurbulence)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgFeTurbulence) StrokeLineCap 

func (e *TagSvgFeTurbulence) StrokeLineCap(value interface{}) (ref *TagSvgFeTurbulence)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgFeTurbulence) StrokeLineJoin 

func (e *TagSvgFeTurbulence) StrokeLineJoin(value interface{}) (ref *TagSvgFeTurbulence)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgFeTurbulence) StrokeMiterLimit 

func (e *TagSvgFeTurbulence) StrokeMiterLimit(value float64) (ref *TagSvgFeTurbulence)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgFeTurbulence) StrokeOpacity 

func (e *TagSvgFeTurbulence) StrokeOpacity(value interface{}) (ref *TagSvgFeTurbulence)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgFeTurbulence) StrokeWidth 

func (e *TagSvgFeTurbulence) StrokeWidth(value interface{}) (ref *TagSvgFeTurbulence)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeTurbulence) Style 

func (e *TagSvgFeTurbulence) Style(value string) (ref *TagSvgFeTurbulence)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgFeTurbulence) Tabindex 

func (e *TagSvgFeTurbulence) Tabindex(value int) (ref *TagSvgFeTurbulence)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgFeTurbulence) Text 

func (e *TagSvgFeTurbulence) Text(value string) (ref *TagSvgFeTurbulence)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgFeTurbulence) TextAnchor 

func (e *TagSvgFeTurbulence) TextAnchor(value interface{}) (ref *TagSvgFeTurbulence)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgFeTurbulence) TextDecoration 

func (e *TagSvgFeTurbulence) TextDecoration(value interface{}) (ref *TagSvgFeTurbulence)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgFeTurbulence) TextRendering 

func (e *TagSvgFeTurbulence) TextRendering(value interface{}) (ref *TagSvgFeTurbulence)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgFeTurbulence) Transform 

func (e *TagSvgFeTurbulence) Transform(value interface{}) (ref *TagSvgFeTurbulence)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgFeTurbulence) Type 

func (e *TagSvgFeTurbulence) Type(value interface{}) (ref *TagSvgFeTurbulence)

Type

English:

Indicates whether the filter primitive should perform a noise or turbulence function. 

Input:
  value: filter primitive
    KSvgTypeTurbulence... (e.g. KSvgTypeTurbulenceFractalNoise)
    any other type: interface{}

Português:

Indica se a primitiva do filtro deve executar uma função de ruído ou turbulência. 

Input:
  value: primitiva do filtro
    KSvgTypeTurbulence... (ex. KSvgTypeTurbulenceFractalNoise)
    any other type: interface{}

func (*TagSvgFeTurbulence) UnicodeBidi 

func (e *TagSvgFeTurbulence) UnicodeBidi(value interface{}) (ref *TagSvgFeTurbulence)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgFeTurbulence) VectorEffect 

func (e *TagSvgFeTurbulence) VectorEffect(value interface{}) (ref *TagSvgFeTurbulence)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgFeTurbulence) Visibility 

func (e *TagSvgFeTurbulence) Visibility(value interface{}) (ref *TagSvgFeTurbulence)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgFeTurbulence) Width 

func (e *TagSvgFeTurbulence) Width(value interface{}) (ref *TagSvgFeTurbulence)

Width

English:

The width attribute defines the horizontal length of an element in the user coordinate system. 

Input:
  value: the horizontal length of an element
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo largura define o comprimento horizontal de um elemento no sistema de coordenadas do usuário. 

Entrada:
  value: o comprimento horizontal de um elemento
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFeTurbulence) WordSpacing 

func (e *TagSvgFeTurbulence) WordSpacing(value interface{}) (ref *TagSvgFeTurbulence)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgFeTurbulence) WritingMode 

func (e *TagSvgFeTurbulence) WritingMode(value interface{}) (ref *TagSvgFeTurbulence)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgFeTurbulence) X 

func (e *TagSvgFeTurbulence) X(value interface{}) (ref *TagSvgFeTurbulence)

X

English:

The x attribute defines an x-axis coordinate in the user coordinate system. 

Input:
  value: defines an x-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo x define uma coordenada do eixo x no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo x
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgFeTurbulence) XmlLang 

func (e *TagSvgFeTurbulence) XmlLang(value interface{}) (ref *TagSvgFeTurbulence)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

func (*TagSvgFeTurbulence) Y 

func (e *TagSvgFeTurbulence) Y(value interface{}) (ref *TagSvgFeTurbulence)

Y

English:

The y attribute defines an y-axis coordinate in the user coordinate system. 

Input:
  value: defines an y-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo y define uma coordenada do eixo y no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo y
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

type TagSvgFilter 

type TagSvgFilter struct {
	// contains filtered or unexported fields
}

TagSvgFilter

English:

The <filter> SVG element defines a custom filter effect by grouping atomic filter primitives. It is never rendered itself, but must be used by the filter attribute on SVG elements, or the filter CSS property for SVG/HTML elements.

Português:

O elemento SVG <filter> define um efeito de filtro personalizado agrupando primitivos de filtro atômico. Ele nunca é renderizado, mas deve ser usado pelo atributo filter em elementos SVG ou pela propriedade CSS filter para elementos SVGHTML.

func (*TagSvgFilter) Append 

func (e *TagSvgFilter) Append(elements ...Compatible) (ref *TagSvgFilter)

func (*TagSvgFilter) AppendById 

func (e *TagSvgFilter) AppendById(appendId string) (ref *TagSvgFilter)

func (*TagSvgFilter) AppendToElement 

func (e *TagSvgFilter) AppendToElement(el js.Value) (ref *TagSvgFilter)

func (*TagSvgFilter) AppendToStage 

func (e *TagSvgFilter) AppendToStage() (ref *TagSvgFilter)

func (*TagSvgFilter) BaselineShift 

func (e *TagSvgFilter) BaselineShift(baselineShift interface{}) (ref *TagSvgFilter)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgFilter) Class 

func (e *TagSvgFilter) Class(class string) (ref *TagSvgFilter)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgFilter) ClipPath 

func (e *TagSvgFilter) ClipPath(clipPath string) (ref *TagSvgFilter)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgFilter) ClipRule 

func (e *TagSvgFilter) ClipRule(value interface{}) (ref *TagSvgFilter)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgFilter) Color 

func (e *TagSvgFilter) Color(value interface{}) (ref *TagSvgFilter)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgFilter) ColorInterpolation 

func (e *TagSvgFilter) ColorInterpolation(value interface{}) (ref *TagSvgFilter)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgFilter) ColorInterpolationFilters 

func (e *TagSvgFilter) ColorInterpolationFilters(value interface{}) (ref *TagSvgFilter)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgFilter) CreateElement 

func (e *TagSvgFilter) CreateElement() (ref *TagSvgFilter)

func (*TagSvgFilter) Cursor 

func (e *TagSvgFilter) Cursor(cursor SvgCursor) (ref *TagSvgFilter)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgFilter) Direction 

func (e *TagSvgFilter) Direction(direction SvgDirection) (ref *TagSvgFilter)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgFilter) Display 

func (e *TagSvgFilter) Display(value interface{}) (ref *TagSvgFilter)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgFilter) DominantBaseline 

func (e *TagSvgFilter) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgFilter)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgFilter) Fill 

func (e *TagSvgFilter) Fill(value interface{}) (ref *TagSvgFilter)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgFilter) FillOpacity 

func (e *TagSvgFilter) FillOpacity(value interface{}) (ref *TagSvgFilter)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgFilter) FillRule 

func (e *TagSvgFilter) FillRule(fillRule SvgFillRule) (ref *TagSvgFilter)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgFilter) Filter 

func (e *TagSvgFilter) Filter(filter string) (ref *TagSvgFilter)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgFilter) FilterUnits 

func (e *TagSvgFilter) FilterUnits(filterUnits SvgFilterUnits) (ref *TagSvgFilter)

FilterUnits

English: 

The filterUnits attribute defines the coordinate system for the attributes x, y, width and height.

Portuguese 

O atributo filterUnits define o sistema de coordenadas para os atributos x, y, largura e altura.

func (*TagSvgFilter) FloodColor 

func (e *TagSvgFilter) FloodColor(floodColor interface{}) (ref *TagSvgFilter)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgFilter) FloodOpacity 

func (e *TagSvgFilter) FloodOpacity(floodOpacity float64) (ref *TagSvgFilter)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgFilter) FontFamily 

func (e *TagSvgFilter) FontFamily(fontFamily string) (ref *TagSvgFilter)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgFilter) FontSize 

func (e *TagSvgFilter) FontSize(fontSize interface{}) (ref *TagSvgFilter)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgFilter) FontSizeAdjust 

func (e *TagSvgFilter) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgFilter)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgFilter) FontStretch 

func (e *TagSvgFilter) FontStretch(fontStretch interface{}) (ref *TagSvgFilter)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgFilter) FontStyle 

func (e *TagSvgFilter) FontStyle(fontStyle FontStyleRule) (ref *TagSvgFilter)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgFilter) FontVariant 

func (e *TagSvgFilter) FontVariant(value interface{}) (ref *TagSvgFilter)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgFilter) FontWeight 

func (e *TagSvgFilter) FontWeight(value interface{}) (ref *TagSvgFilter)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgFilter) Get 

func (e *TagSvgFilter) Get() (el js.Value)

func (*TagSvgFilter) HRef 

func (e *TagSvgFilter) HRef(href string) (ref *TagSvgFilter)

HRef

English: 

The href attribute defines a link to a resource as a reference URL. The exact meaning of that link depends on the
context of each element using it.

 Notes:
   * Specifications before SVG 2 defined an xlink:href attribute, which is now rendered obsolete by the href
     attribute.
     If you need to support earlier browser versions, the deprecated xlink:href attribute can be used as a fallback
     in addition to the href attribute, e.g. <use href="some-id" xlink:href="some-id x="5" y="5" />.

Português: 

O atributo href define um link para um recurso como um URL de referência. O significado exato desse link depende do
contexto de cada elemento que o utiliza.

 Notas:
   * As especificações anteriores ao SVG 2 definiam um atributo xlink:href, que agora se torna obsoleto pelo
     atributo href.
     Se você precisar oferecer suporte a versões anteriores do navegador, o atributo obsoleto xlink:href pode ser
     usado como um substituto além do atributo href, por exemplo,
     <use href="some-id" xlink:href="some-id x="5" y="5" />.

func (*TagSvgFilter) Height 

func (e *TagSvgFilter) Height(height interface{}) (ref *TagSvgFilter)

Height

English: 

The height attribute defines the vertical length of an element in the user coordinate system.
     float32: 1.0 = "100%"
     any other type: interface{}

Português: 

O atributo height define o comprimento vertical de um elemento no sistema de coordenadas do usuário.
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

func (*TagSvgFilter) Html 

func (e *TagSvgFilter) Html(value string) (ref *TagSvgFilter)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgFilter) Id 

func (e *TagSvgFilter) Id(id string) (ref *TagSvgFilter)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgFilter) ImageRendering 

func (e *TagSvgFilter) ImageRendering(imageRendering string) (ref *TagSvgFilter)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgFilter) Init 

func (e *TagSvgFilter) Init() (ref *TagSvgFilter)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgFilter) Lang 

func (e *TagSvgFilter) Lang(value interface{}) (ref *TagSvgFilter)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgFilter) LetterSpacing 

func (e *TagSvgFilter) LetterSpacing(value float64) (ref *TagSvgFilter)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgFilter) LightingColor 

func (e *TagSvgFilter) LightingColor(value interface{}) (ref *TagSvgFilter)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgFilter) MarkerEnd 

func (e *TagSvgFilter) MarkerEnd(value interface{}) (ref *TagSvgFilter)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgFilter) MarkerMid 

func (e *TagSvgFilter) MarkerMid(value interface{}) (ref *TagSvgFilter)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgFilter) MarkerStart 

func (e *TagSvgFilter) MarkerStart(value interface{}) (ref *TagSvgFilter)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgFilter) Mask 

func (e *TagSvgFilter) Mask(value interface{}) (ref *TagSvgFilter)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgFilter) Opacity 

func (e *TagSvgFilter) Opacity(value interface{}) (ref *TagSvgFilter)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgFilter) Overflow 

func (e *TagSvgFilter) Overflow(value interface{}) (ref *TagSvgFilter)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgFilter) PointerEvents 

func (e *TagSvgFilter) PointerEvents(value interface{}) (ref *TagSvgFilter)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgFilter) PrimitiveUnits 

func (e *TagSvgFilter) PrimitiveUnits(value interface{}) (ref *TagSvgFilter)

PrimitiveUnits

English:

The primitiveUnits attribute specifies the coordinate system for the various length values within the filter primitives and for the attributes that define the filter primitive subregion. 

Input:
  value: specifies the coordinate system
    const KSvgUnits... (e.g. KSvgUnitsObjectBoundingBox)
    any other type: interface{}

Português:

O atributo primitivaUnits especifica o sistema de coordenadas para os vários valores de comprimento dentro das primitivas de filtro e para os atributos que definem a sub-região da primitiva de filtro. 

Entrada:
  value: especifica o sistema de coordenadas
    const KSvgUnits... (e.g. KSvgUnitsObjectBoundingBox)
    qualquer outro tipo: interface{}

func (*TagSvgFilter) ShapeRendering 

func (e *TagSvgFilter) ShapeRendering(value interface{}) (ref *TagSvgFilter)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgFilter) StopColor 

func (e *TagSvgFilter) StopColor(value interface{}) (ref *TagSvgFilter)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgFilter) StopOpacity 

func (e *TagSvgFilter) StopOpacity(value interface{}) (ref *TagSvgFilter)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgFilter) Stroke 

func (e *TagSvgFilter) Stroke(value interface{}) (ref *TagSvgFilter)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgFilter) StrokeDasharray 

func (e *TagSvgFilter) StrokeDasharray(value interface{}) (ref *TagSvgFilter)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgFilter) StrokeLineCap 

func (e *TagSvgFilter) StrokeLineCap(value interface{}) (ref *TagSvgFilter)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgFilter) StrokeLineJoin 

func (e *TagSvgFilter) StrokeLineJoin(value interface{}) (ref *TagSvgFilter)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgFilter) StrokeMiterLimit 

func (e *TagSvgFilter) StrokeMiterLimit(value float64) (ref *TagSvgFilter)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgFilter) StrokeOpacity 

func (e *TagSvgFilter) StrokeOpacity(value interface{}) (ref *TagSvgFilter)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgFilter) StrokeWidth 

func (e *TagSvgFilter) StrokeWidth(value interface{}) (ref *TagSvgFilter)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFilter) Style 

func (e *TagSvgFilter) Style(value string) (ref *TagSvgFilter)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgFilter) Tabindex 

func (e *TagSvgFilter) Tabindex(value int) (ref *TagSvgFilter)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgFilter) Text 

func (e *TagSvgFilter) Text(value string) (ref *TagSvgFilter)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgFilter) TextAnchor 

func (e *TagSvgFilter) TextAnchor(value interface{}) (ref *TagSvgFilter)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgFilter) TextDecoration 

func (e *TagSvgFilter) TextDecoration(value interface{}) (ref *TagSvgFilter)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgFilter) TextRendering 

func (e *TagSvgFilter) TextRendering(value interface{}) (ref *TagSvgFilter)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgFilter) Transform 

func (e *TagSvgFilter) Transform(value interface{}) (ref *TagSvgFilter)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgFilter) UnicodeBidi 

func (e *TagSvgFilter) UnicodeBidi(value interface{}) (ref *TagSvgFilter)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgFilter) VectorEffect 

func (e *TagSvgFilter) VectorEffect(value interface{}) (ref *TagSvgFilter)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgFilter) Visibility 

func (e *TagSvgFilter) Visibility(value interface{}) (ref *TagSvgFilter)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgFilter) Width 

func (e *TagSvgFilter) Width(value interface{}) (ref *TagSvgFilter)

Width

English:

The width attribute defines the horizontal length of an element in the user coordinate system. 

Input:
  value: the horizontal length of an element
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo largura define o comprimento horizontal de um elemento no sistema de coordenadas do usuário. 

Entrada:
  value: o comprimento horizontal de um elemento
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgFilter) WordSpacing 

func (e *TagSvgFilter) WordSpacing(value interface{}) (ref *TagSvgFilter)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgFilter) WritingMode 

func (e *TagSvgFilter) WritingMode(value interface{}) (ref *TagSvgFilter)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgFilter) X 

func (e *TagSvgFilter) X(value interface{}) (ref *TagSvgFilter)

X

English:

The x attribute defines an x-axis coordinate in the user coordinate system. 

Input:
  value: defines an x-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo x define uma coordenada do eixo x no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo x
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgFilter) XLinkHRef deprecated 

func (e *TagSvgFilter) XLinkHRef(value interface{}) (ref *TagSvgFilter)

XLinkHRef

English:

Deprecated: use HRef() function

The xlink:href attribute defines a reference to a resource as a reference IRI. The exact meaning of that link depends on the context of each element using it. 

Notes:
  * SVG 2 removed the need for the xlink namespace, so instead of xlink:href you should use href. If you need to
    support earlier browser versions, the deprecated xlink:href attribute can be used as a fallback in addition to
    the href attribute, e.g. <use href="some-id" xlink:href="some-id" x="5" y="5" />.

Português:

Obsoleto: use a função HRef()

O atributo xlink:href define uma referência a um recurso como um IRI de referência. O significado exato desse link depende do contexto de cada elemento que o utiliza. 

Notas:
  * O SVG 2 removeu a necessidade do namespace xlink, então ao invés de xlink:href você deve usar href. Se você
    precisar oferecer suporte a versões anteriores do navegador, o atributo obsoleto xlink:href pode ser usado como
    um substituto além do atributo href, por exemplo, <use href="some-id" xlink:href="some-id" x="5" y="5" >.

func (*TagSvgFilter) XmlLang 

func (e *TagSvgFilter) XmlLang(value interface{}) (ref *TagSvgFilter)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

func (*TagSvgFilter) Y 

func (e *TagSvgFilter) Y(value interface{}) (ref *TagSvgFilter)

Y

English:

The y attribute defines an y-axis coordinate in the user coordinate system. 

Input:
  value: defines an y-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo y define uma coordenada do eixo y no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo y
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

type TagSvgForeignObject 

type TagSvgForeignObject struct {
	// contains filtered or unexported fields
}

TagSvgForeignObject

English:

The <defs> element is used to store graphical objects that will be used at a later time.

Objects created inside a <defs> element are not rendered directly. To display them you have to reference them (with a <use> element for example).

Graphical objects can be referenced from anywhere, however, defining these objects inside of a <defs> element promotes understandability of the SVG content and is beneficial to the overall accessibility of the document.

Português:

O elemento <defs> é usado para armazenar objetos gráficos que serão usados posteriormente.

Objetos criados dentro de um elemento <defs> não são renderizados diretamente. Para exibi-los, você deve referenciá-los (com um elemento <use>, por exemplo).

Graphical objects can be referenced from anywhere, however, defining these objects inside of a <defs> element promotes understandability of the SVG content and is beneficial to the overall accessibility of the document.

func (*TagSvgForeignObject) Append 

func (e *TagSvgForeignObject) Append(elements ...Compatible) (ref *TagSvgForeignObject)

func (*TagSvgForeignObject) AppendById 

func (e *TagSvgForeignObject) AppendById(appendId string) (ref *TagSvgForeignObject)

func (*TagSvgForeignObject) AppendToElement 

func (e *TagSvgForeignObject) AppendToElement(el js.Value) (ref *TagSvgForeignObject)

func (*TagSvgForeignObject) AppendToStage 

func (e *TagSvgForeignObject) AppendToStage() (ref *TagSvgForeignObject)

func (*TagSvgForeignObject) BaselineShift 

func (e *TagSvgForeignObject) BaselineShift(baselineShift interface{}) (ref *TagSvgForeignObject)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgForeignObject) Class 

func (e *TagSvgForeignObject) Class(class string) (ref *TagSvgForeignObject)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgForeignObject) ClipPath 

func (e *TagSvgForeignObject) ClipPath(clipPath string) (ref *TagSvgForeignObject)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgForeignObject) ClipRule 

func (e *TagSvgForeignObject) ClipRule(value interface{}) (ref *TagSvgForeignObject)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgForeignObject) Color 

func (e *TagSvgForeignObject) Color(value interface{}) (ref *TagSvgForeignObject)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgForeignObject) ColorInterpolation 

func (e *TagSvgForeignObject) ColorInterpolation(value interface{}) (ref *TagSvgForeignObject)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgForeignObject) ColorInterpolationFilters 

func (e *TagSvgForeignObject) ColorInterpolationFilters(value interface{}) (ref *TagSvgForeignObject)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgForeignObject) CreateElement 

func (e *TagSvgForeignObject) CreateElement() (ref *TagSvgForeignObject)

func (*TagSvgForeignObject) Cursor 

func (e *TagSvgForeignObject) Cursor(cursor SvgCursor) (ref *TagSvgForeignObject)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgForeignObject) Direction 

func (e *TagSvgForeignObject) Direction(direction SvgDirection) (ref *TagSvgForeignObject)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgForeignObject) Display 

func (e *TagSvgForeignObject) Display(value interface{}) (ref *TagSvgForeignObject)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgForeignObject) DominantBaseline 

func (e *TagSvgForeignObject) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgForeignObject)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgForeignObject) Fill 

func (e *TagSvgForeignObject) Fill(value interface{}) (ref *TagSvgForeignObject)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgForeignObject) FillOpacity 

func (e *TagSvgForeignObject) FillOpacity(value interface{}) (ref *TagSvgForeignObject)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgForeignObject) FillRule 

func (e *TagSvgForeignObject) FillRule(fillRule SvgFillRule) (ref *TagSvgForeignObject)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgForeignObject) Filter 

func (e *TagSvgForeignObject) Filter(filter string) (ref *TagSvgForeignObject)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgForeignObject) FloodColor 

func (e *TagSvgForeignObject) FloodColor(floodColor interface{}) (ref *TagSvgForeignObject)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgForeignObject) FloodOpacity 

func (e *TagSvgForeignObject) FloodOpacity(floodOpacity float64) (ref *TagSvgForeignObject)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgForeignObject) FontFamily 

func (e *TagSvgForeignObject) FontFamily(fontFamily string) (ref *TagSvgForeignObject)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgForeignObject) FontSize 

func (e *TagSvgForeignObject) FontSize(fontSize interface{}) (ref *TagSvgForeignObject)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgForeignObject) FontSizeAdjust 

func (e *TagSvgForeignObject) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgForeignObject)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgForeignObject) FontStretch 

func (e *TagSvgForeignObject) FontStretch(fontStretch interface{}) (ref *TagSvgForeignObject)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgForeignObject) FontStyle 

func (e *TagSvgForeignObject) FontStyle(fontStyle FontStyleRule) (ref *TagSvgForeignObject)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgForeignObject) FontVariant 

func (e *TagSvgForeignObject) FontVariant(value interface{}) (ref *TagSvgForeignObject)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgForeignObject) FontWeight 

func (e *TagSvgForeignObject) FontWeight(value interface{}) (ref *TagSvgForeignObject)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgForeignObject) Get 

func (e *TagSvgForeignObject) Get() (el js.Value)

func (*TagSvgForeignObject) Height 

func (e *TagSvgForeignObject) Height(height interface{}) (ref *TagSvgForeignObject)

Height

English: 

The height attribute defines the vertical length of an element in the user coordinate system.
     float32: 1.0 = "100%"
     any other type: interface{}

Português: 

O atributo height define o comprimento vertical de um elemento no sistema de coordenadas do usuário.
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

func (*TagSvgForeignObject) Html 

func (e *TagSvgForeignObject) Html(value string) (ref *TagSvgForeignObject)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgForeignObject) Id 

func (e *TagSvgForeignObject) Id(id string) (ref *TagSvgForeignObject)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgForeignObject) ImageRendering 

func (e *TagSvgForeignObject) ImageRendering(imageRendering string) (ref *TagSvgForeignObject)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgForeignObject) Init 

func (e *TagSvgForeignObject) Init() (ref *TagSvgForeignObject)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgForeignObject) Lang 

func (e *TagSvgForeignObject) Lang(value interface{}) (ref *TagSvgForeignObject)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgForeignObject) LetterSpacing 

func (e *TagSvgForeignObject) LetterSpacing(value float64) (ref *TagSvgForeignObject)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgForeignObject) LightingColor 

func (e *TagSvgForeignObject) LightingColor(value interface{}) (ref *TagSvgForeignObject)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgForeignObject) MarkerEnd 

func (e *TagSvgForeignObject) MarkerEnd(value interface{}) (ref *TagSvgForeignObject)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgForeignObject) MarkerMid 

func (e *TagSvgForeignObject) MarkerMid(value interface{}) (ref *TagSvgForeignObject)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgForeignObject) MarkerStart 

func (e *TagSvgForeignObject) MarkerStart(value interface{}) (ref *TagSvgForeignObject)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgForeignObject) Mask 

func (e *TagSvgForeignObject) Mask(value interface{}) (ref *TagSvgForeignObject)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgForeignObject) Opacity 

func (e *TagSvgForeignObject) Opacity(value interface{}) (ref *TagSvgForeignObject)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgForeignObject) Overflow 

func (e *TagSvgForeignObject) Overflow(value interface{}) (ref *TagSvgForeignObject)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgForeignObject) PointerEvents 

func (e *TagSvgForeignObject) PointerEvents(value interface{}) (ref *TagSvgForeignObject)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgForeignObject) ShapeRendering 

func (e *TagSvgForeignObject) ShapeRendering(value interface{}) (ref *TagSvgForeignObject)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgForeignObject) StopColor 

func (e *TagSvgForeignObject) StopColor(value interface{}) (ref *TagSvgForeignObject)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgForeignObject) StopOpacity 

func (e *TagSvgForeignObject) StopOpacity(value interface{}) (ref *TagSvgForeignObject)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgForeignObject) Stroke 

func (e *TagSvgForeignObject) Stroke(value interface{}) (ref *TagSvgForeignObject)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgForeignObject) StrokeDasharray 

func (e *TagSvgForeignObject) StrokeDasharray(value interface{}) (ref *TagSvgForeignObject)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgForeignObject) StrokeLineCap 

func (e *TagSvgForeignObject) StrokeLineCap(value interface{}) (ref *TagSvgForeignObject)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgForeignObject) StrokeLineJoin 

func (e *TagSvgForeignObject) StrokeLineJoin(value interface{}) (ref *TagSvgForeignObject)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgForeignObject) StrokeMiterLimit 

func (e *TagSvgForeignObject) StrokeMiterLimit(value float64) (ref *TagSvgForeignObject)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgForeignObject) StrokeOpacity 

func (e *TagSvgForeignObject) StrokeOpacity(value interface{}) (ref *TagSvgForeignObject)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgForeignObject) StrokeWidth 

func (e *TagSvgForeignObject) StrokeWidth(value interface{}) (ref *TagSvgForeignObject)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgForeignObject) Style 

func (e *TagSvgForeignObject) Style(value string) (ref *TagSvgForeignObject)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgForeignObject) Tabindex 

func (e *TagSvgForeignObject) Tabindex(value int) (ref *TagSvgForeignObject)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgForeignObject) Text 

func (e *TagSvgForeignObject) Text(value string) (ref *TagSvgForeignObject)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgForeignObject) TextAnchor 

func (e *TagSvgForeignObject) TextAnchor(value interface{}) (ref *TagSvgForeignObject)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgForeignObject) TextDecoration 

func (e *TagSvgForeignObject) TextDecoration(value interface{}) (ref *TagSvgForeignObject)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgForeignObject) TextRendering 

func (e *TagSvgForeignObject) TextRendering(value interface{}) (ref *TagSvgForeignObject)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgForeignObject) Transform 

func (e *TagSvgForeignObject) Transform(value interface{}) (ref *TagSvgForeignObject)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgForeignObject) UnicodeBidi 

func (e *TagSvgForeignObject) UnicodeBidi(value interface{}) (ref *TagSvgForeignObject)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgForeignObject) VectorEffect 

func (e *TagSvgForeignObject) VectorEffect(value interface{}) (ref *TagSvgForeignObject)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgForeignObject) Visibility 

func (e *TagSvgForeignObject) Visibility(value interface{}) (ref *TagSvgForeignObject)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgForeignObject) Width 

func (e *TagSvgForeignObject) Width(value interface{}) (ref *TagSvgForeignObject)

Width

English:

The width attribute defines the horizontal length of an element in the user coordinate system. 

Input:
  value: the horizontal length of an element
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo largura define o comprimento horizontal de um elemento no sistema de coordenadas do usuário. 

Entrada:
  value: o comprimento horizontal de um elemento
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgForeignObject) WordSpacing 

func (e *TagSvgForeignObject) WordSpacing(value interface{}) (ref *TagSvgForeignObject)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgForeignObject) WritingMode 

func (e *TagSvgForeignObject) WritingMode(value interface{}) (ref *TagSvgForeignObject)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgForeignObject) X 

func (e *TagSvgForeignObject) X(value interface{}) (ref *TagSvgForeignObject)

X

English:

The x attribute defines an x-axis coordinate in the user coordinate system. 

Input:
  value: defines an x-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo x define uma coordenada do eixo x no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo x
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgForeignObject) XmlLang 

func (e *TagSvgForeignObject) XmlLang(value interface{}) (ref *TagSvgForeignObject)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

func (*TagSvgForeignObject) Y 

func (e *TagSvgForeignObject) Y(value interface{}) (ref *TagSvgForeignObject)

Y

English:

The y attribute defines an y-axis coordinate in the user coordinate system. 

Input:
  value: defines an y-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo y define uma coordenada do eixo y no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo y
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

type TagSvgG 

type TagSvgG struct {
	// contains filtered or unexported fields
}

TagSvgG

English:

The <g> SVG element is a container used to group other SVG elements.

Transformations applied to the <g> element are performed on its child elements, and its attributes are inherited by its children. It can also group multiple elements to be referenced later with the <use> element.

Português:

O elemento SVG <g> é um contêiner usado para agrupar outros elementos SVG.

As transformações aplicadas ao elemento <g> são realizadas em seus elementos filhos, e seus atributos são herdados por seus filhos. Ele também pode agrupar vários elementos para serem referenciados posteriormente com o elemento <use>.

func (*TagSvgG) Append 

func (e *TagSvgG) Append(elements ...Compatible) (ref *TagSvgG)

func (*TagSvgG) AppendById 

func (e *TagSvgG) AppendById(appendId string) (ref *TagSvgG)

func (*TagSvgG) AppendToElement 

func (e *TagSvgG) AppendToElement(el js.Value) (ref *TagSvgG)

func (*TagSvgG) AppendToStage 

func (e *TagSvgG) AppendToStage() (ref *TagSvgG)

func (*TagSvgG) BaselineShift 

func (e *TagSvgG) BaselineShift(baselineShift interface{}) (ref *TagSvgG)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgG) Class 

func (e *TagSvgG) Class(class string) (ref *TagSvgG)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgG) ClipPath 

func (e *TagSvgG) ClipPath(clipPath string) (ref *TagSvgG)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgG) ClipRule 

func (e *TagSvgG) ClipRule(value interface{}) (ref *TagSvgG)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgG) Color 

func (e *TagSvgG) Color(value interface{}) (ref *TagSvgG)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgG) ColorInterpolation 

func (e *TagSvgG) ColorInterpolation(value interface{}) (ref *TagSvgG)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgG) ColorInterpolationFilters 

func (e *TagSvgG) ColorInterpolationFilters(value interface{}) (ref *TagSvgG)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgG) CreateElement 

func (e *TagSvgG) CreateElement() (ref *TagSvgG)

func (*TagSvgG) Cursor 

func (e *TagSvgG) Cursor(cursor SvgCursor) (ref *TagSvgG)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgG) Direction 

func (e *TagSvgG) Direction(direction SvgDirection) (ref *TagSvgG)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgG) Display 

func (e *TagSvgG) Display(value interface{}) (ref *TagSvgG)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgG) DominantBaseline 

func (e *TagSvgG) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgG)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgG) Fill 

func (e *TagSvgG) Fill(value interface{}) (ref *TagSvgG)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgG) FillOpacity 

func (e *TagSvgG) FillOpacity(value interface{}) (ref *TagSvgG)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgG) FillRule 

func (e *TagSvgG) FillRule(fillRule SvgFillRule) (ref *TagSvgG)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgG) Filter 

func (e *TagSvgG) Filter(filter string) (ref *TagSvgG)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgG) FloodColor 

func (e *TagSvgG) FloodColor(floodColor interface{}) (ref *TagSvgG)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgG) FloodOpacity 

func (e *TagSvgG) FloodOpacity(floodOpacity float64) (ref *TagSvgG)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgG) FontFamily 

func (e *TagSvgG) FontFamily(fontFamily string) (ref *TagSvgG)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgG) FontSize 

func (e *TagSvgG) FontSize(fontSize interface{}) (ref *TagSvgG)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgG) FontSizeAdjust 

func (e *TagSvgG) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgG)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgG) FontStretch 

func (e *TagSvgG) FontStretch(fontStretch interface{}) (ref *TagSvgG)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgG) FontStyle 

func (e *TagSvgG) FontStyle(fontStyle FontStyleRule) (ref *TagSvgG)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgG) FontVariant 

func (e *TagSvgG) FontVariant(value interface{}) (ref *TagSvgG)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgG) FontWeight 

func (e *TagSvgG) FontWeight(value interface{}) (ref *TagSvgG)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgG) Get 

func (e *TagSvgG) Get() (el js.Value)

func (*TagSvgG) Html 

func (e *TagSvgG) Html(value string) (ref *TagSvgG)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgG) Id 

func (e *TagSvgG) Id(id string) (ref *TagSvgG)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgG) ImageRendering 

func (e *TagSvgG) ImageRendering(imageRendering string) (ref *TagSvgG)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgG) Init 

func (e *TagSvgG) Init() (ref *TagSvgG)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgG) Lang 

func (e *TagSvgG) Lang(value interface{}) (ref *TagSvgG)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgG) LetterSpacing 

func (e *TagSvgG) LetterSpacing(value float64) (ref *TagSvgG)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgG) LightingColor 

func (e *TagSvgG) LightingColor(value interface{}) (ref *TagSvgG)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgG) MarkerEnd 

func (e *TagSvgG) MarkerEnd(value interface{}) (ref *TagSvgG)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgG) MarkerMid 

func (e *TagSvgG) MarkerMid(value interface{}) (ref *TagSvgG)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgG) MarkerStart 

func (e *TagSvgG) MarkerStart(value interface{}) (ref *TagSvgG)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgG) Mask 

func (e *TagSvgG) Mask(value interface{}) (ref *TagSvgG)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgG) Opacity 

func (e *TagSvgG) Opacity(value interface{}) (ref *TagSvgG)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgG) Overflow 

func (e *TagSvgG) Overflow(value interface{}) (ref *TagSvgG)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgG) PointerEvents 

func (e *TagSvgG) PointerEvents(value interface{}) (ref *TagSvgG)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgG) ShapeRendering 

func (e *TagSvgG) ShapeRendering(value interface{}) (ref *TagSvgG)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgG) StopColor 

func (e *TagSvgG) StopColor(value interface{}) (ref *TagSvgG)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgG) StopOpacity 

func (e *TagSvgG) StopOpacity(value interface{}) (ref *TagSvgG)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgG) Stroke 

func (e *TagSvgG) Stroke(value interface{}) (ref *TagSvgG)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgG) StrokeDasharray 

func (e *TagSvgG) StrokeDasharray(value interface{}) (ref *TagSvgG)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgG) StrokeLineCap 

func (e *TagSvgG) StrokeLineCap(value interface{}) (ref *TagSvgG)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgG) StrokeLineJoin 

func (e *TagSvgG) StrokeLineJoin(value interface{}) (ref *TagSvgG)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgG) StrokeMiterLimit 

func (e *TagSvgG) StrokeMiterLimit(value float64) (ref *TagSvgG)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgG) StrokeOpacity 

func (e *TagSvgG) StrokeOpacity(value interface{}) (ref *TagSvgG)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgG) StrokeWidth 

func (e *TagSvgG) StrokeWidth(value interface{}) (ref *TagSvgG)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgG) Style 

func (e *TagSvgG) Style(value string) (ref *TagSvgG)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgG) Tabindex 

func (e *TagSvgG) Tabindex(value int) (ref *TagSvgG)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgG) Text 

func (e *TagSvgG) Text(value string) (ref *TagSvgG)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgG) TextAnchor 

func (e *TagSvgG) TextAnchor(value interface{}) (ref *TagSvgG)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgG) TextDecoration 

func (e *TagSvgG) TextDecoration(value interface{}) (ref *TagSvgG)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgG) TextRendering 

func (e *TagSvgG) TextRendering(value interface{}) (ref *TagSvgG)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgG) Transform 

func (e *TagSvgG) Transform(value interface{}) (ref *TagSvgG)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgG) UnicodeBidi 

func (e *TagSvgG) UnicodeBidi(value interface{}) (ref *TagSvgG)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgG) VectorEffect 

func (e *TagSvgG) VectorEffect(value interface{}) (ref *TagSvgG)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgG) Visibility 

func (e *TagSvgG) Visibility(value interface{}) (ref *TagSvgG)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgG) WordSpacing 

func (e *TagSvgG) WordSpacing(value interface{}) (ref *TagSvgG)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgG) WritingMode 

func (e *TagSvgG) WritingMode(value interface{}) (ref *TagSvgG)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgG) XmlLang 

func (e *TagSvgG) XmlLang(value interface{}) (ref *TagSvgG)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

type TagSvgGlobal 

type TagSvgGlobal struct {
	// contains filtered or unexported fields
}

func (*TagSvgGlobal) Accumulate 

func (e *TagSvgGlobal) Accumulate(value interface{}) (ref *TagSvgGlobal)

Accumulate

English: 

The accumulate attribute controls whether or not an animation is cumulative.

 Input:
   value: controls whether or not an animation is cumulative
     const: KSvgAccumulate... (e.g. KSvgAccumulateSum)
     any other type: interface{}

It is frequently useful for repeated animations to build upon the previous results, accumulating with each iteration. This attribute said to the animation if the value is added to the previous animated attribute's value on each iteration. 

Notes:
  * This attribute is ignored if the target attribute value does not support addition, or if the animation element
    does not repeat;
  * This attribute will be ignored if the animation function is specified with only the to attribute.

Português: 

O atributo acumular controla se uma animação é cumulativa ou não.

 Entrada:
   value: controla se uma animação é cumulativa ou não
     const: KSvgAccumulate... (ex. KSvgAccumulateSum)
     qualquer outro tipo: interface{}

Frequentemente, é útil que as animações repetidas se baseiem nos resultados anteriores, acumulando a cada iteração. Este atributo é dito à animação se o valor for adicionado ao valor do atributo animado anterior em cada iteração. 

Notas:
  * Esse atributo será ignorado se o valor do atributo de destino não suportar adição ou se o elemento de animação
    não se repetir;
  * Este atributo será ignorado se a função de animação for especificada apenas com o atributo to.

func (*TagSvgGlobal) Additive 

func (e *TagSvgGlobal) Additive(value interface{}) (ref *TagSvgGlobal)

Additive

English: 

The additive attribute controls whether or not an animation is additive.

 Input:
   value: controls whether or not an animation is additive
     const: KSvgAdditive... (e.g. KSvgAdditiveSum)
     any other type: interface{}

It is frequently useful to define animation as an offset or delta to an attribute's value, rather than as absolute values.

Português: 

O atributo aditivo controla se uma animação é ou não aditiva.

 Entrada:
   value: controla se uma animação é aditiva ou não
     const: KSvgAdditive... (ex. KSvgAdditiveSum)
     qualquer outro tipo: interface{}

É frequentemente útil definir a animação como um deslocamento ou delta para o valor de um atributo, em vez de valores absolutos.

func (*TagSvgGlobal) AlignmentBaseline 

func (e *TagSvgGlobal) AlignmentBaseline(alignmentBaseline interface{}) (ref *TagSvgGlobal)

AlignmentBaseline #presentation

English: 

The alignment-baseline attribute specifies how an object is aligned with respect to its parent. This property
specifies which baseline of this element is to be aligned with the corresponding baseline of the parent.
For example, this allows alphabetic baselines in Roman text to stay aligned across font size changes.
It defaults to the baseline with the same name as the computed value of the alignment-baseline property.

 Input:
   alignmentBaseline: specifies how an object is aligned with respect to its parent.
     string: url(#myClip)
     consts KSvgAlignmentBaseline... (e.g. KSvgAlignmentBaselineTextBeforeEdge)
     any other type: interface{}

 Notes:
   * As a presentation attribute alignment-baseline can be used as a CSS property.
   * SVG 2 introduces some changes to the definition of this property. In particular: the values auto, before-edge,
     and after-edge have been removed. For backwards compatibility, text-before-edge may be mapped to text-top and
     text-after-edge to text-bottom. Neither text-before-edge nor text-after-edge should be used with the
     vertical-align property.

Português: 

O atributo alinhamento-base especifica como um objeto é alinhado em relação ao seu pai. Esta propriedade especifica
qual linha de base deste elemento deve ser alinhada com a linha de base correspondente do pai. Por exemplo, isso
permite que as linhas de base alfabéticas em texto romano permaneçam alinhadas nas alterações de tamanho da fonte.
O padrão é a linha de base com o mesmo nome que o valor calculado da propriedade de linha de base de alinhamento.

 Input:
   alignmentBaseline: especifica como um objeto é alinhado em relação ao seu pai.
     string: url(#myClip)
     consts KSvgAlignmentBaseline...  (ex. KSvgAlignmentBaselineTextBeforeEdge)
     qualquer outro tipo: interface{}

 Notas:
   * Como um atributo de apresentação, a linha de base de alinhamento pode ser usada como uma propriedade CSS.
   * O SVG 2 introduz algumas mudanças na definição desta propriedade. Em particular: os valores auto, before-edge e
     after-edge foram removidos. Para compatibilidade com versões anteriores, text-before-edge pode ser mapeado para
     text-top e text-after-edge para text-bottom. Nem text-before-edge nem text-after-edge devem ser usados com a
     propriedade vertical-align.

func (*TagSvgGlobal) Amplitude 

func (e *TagSvgGlobal) Amplitude(amplitude interface{}) (ref *TagSvgGlobal)

Amplitude

English: 

The amplitude attribute controls the amplitude of the gamma function of a component transfer element when its type
attribute is gamma.

 Input:
   amplitude: controls the amplitude of the gamma function
     float32: 1.0 = "100%"
     any other type: interface{}

Português: 

O atributo amplitude controla à amplitude da função gama de um elemento de transferência de componente quando seu
atributo de tipo é gama.

 Entrada:
   amplitude: controla a amplitude da função de gama
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

func (*TagSvgGlobal) AttributeName 

func (e *TagSvgGlobal) AttributeName(attributeName string) (ref *TagSvgGlobal)

AttributeName

English: 

The attributeName attribute indicates the name of the CSS property or attribute of the target element that is going
to be changed during an animation.

Português: 

O atributo attributeName indica o nome da propriedade CSS ou atributo do elemento de destino que será alterado
durante uma animação.

func (*TagSvgGlobal) Azimuth 

func (e *TagSvgGlobal) Azimuth(azimuth float64) (ref *TagSvgGlobal)

Azimuth

English: 

The azimuth attribute specifies the direction angle for the light source on the XY plane (clockwise), in degrees
from the x axis.

 Input:
   azimuth: specifies the direction angle for the light source on the XY plane

Português: 

O atributo azimute especifica o ângulo de direção da fonte de luz no plano XY (sentido horário), em graus a partir
do eixo x.

 Input:
   azimuth: especifica o ângulo de direção para a fonte de luz no plano XY

func (*TagSvgGlobal) BaseFrequency 

func (e *TagSvgGlobal) BaseFrequency(baseFrequency float64) (ref *TagSvgGlobal)

BaseFrequency

English: 

The baseFrequency attribute represents the base frequency parameter for the noise function of the <feTurbulence> filter primitive.

 Input:
   baseFrequency: represents the base frequency parameter for the noise function

Português: 

O atributo baseFrequency representa o parâmetro de frequência base para a função de ruído da primitiva de filtro <feTurbulence>.

 Entrada:
   baseFrequency: representa o parâmetro de frequência base para a função de ruído

func (*TagSvgGlobal) BaselineShift 

func (e *TagSvgGlobal) BaselineShift(baselineShift interface{}) (ref *TagSvgGlobal)

BaselineShift #presentation

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)
     any other type: interface{}

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgGlobal) Begin 

func (e *TagSvgGlobal) Begin(begin interface{}) (ref *TagSvgGlobal)

Begin

English: 

The begin attribute defines when an animation should begin or when an element should be discarded.

 Input:
   begin: defines when an animation should begin or when an element should be discarded.
     offset-value: This value defines a clock-value that represents a point in time relative to the beginning of the
       SVG document (usually the load or DOMContentLoaded event). Negative values are valid.
       (e.g. time.Second*5 or "5s")
     syncbase-value: This value defines a syncbase and an optional offset from that syncbase. The element's
       animation start time is defined relative to the begin or active end of another animation.
       A valid syncbase-value consists of an ID reference to another animation element followed by a dot and either
       begin or end to identify whether to synchronize with the beginning or active end of the referenced animation
       element. An optional offset value as defined in <offset-value> can be appended.
       (e.g. "0s;third.end", "first.end" or "second.end")
     event-value: This value defines an event and an optional offset that determines the time at which the element's
       animation should begin. The animation start time is defined relative to the time that the specified event is
       fired.
       A valid event-value consists of an element ID followed by a dot and one of the supported events for that
       element. All valid events (not necessarily supported by all elements) are defined by the DOM and HTML
       specifications. Those are: 'focus', 'blur', 'focusin', 'focusout', 'activate', 'auxclick', 'click',
       'dblclick', 'mousedown', 'mouseenter', 'mouseleave', 'mousemove', 'mouseout', 'mouseover', 'mouseup',
       'wheel', 'beforeinput', 'input', 'keydown', 'keyup', 'compositionstart', 'compositionupdate',
       'compositionend', 'load', 'unload', 'abort', 'error', 'select', 'resize', 'scroll', 'beginEvent', 'endEvent',
       and 'repeatEvent'. An optional offset value as defined in <offset-value> can be appended.
       (e.g. "startButton.click")
     repeat-value: This value defines a qualified repeat event. The element animation start time is defined relative
       to the time that the repeat event is raised with the specified iteration value.
       A valid repeat value consists of an element ID followed by a dot and the function repeat() with an integer
       value specifying the number of repetitions as parameter. An optional offset value as defined in
       <offset-value> can be appended.
       (e.g. "0s;myLoop.end", "myLoop.begin", "myLoop.repeat(1)" or "myLoop.repeat(2)")
     accessKey-value: This value defines an access key that should trigger the animation. The element animation will
       begin when the user presses the specified key.
       A valid accessKey-value consists of the function accessKey() with the character to be input as parameter. An
       optional offset value as defined in <offset-value> can be appended.
       (e.g. "accessKey(s)")
     wallclock-sync-value: This value defines the animation start time as a real-world clock time.
       A valid wallclock-sync-value consists of the function wallclock() with a time value as parameter. The time
       syntax is based upon the syntax defined in ISO 8601.
       (e.g. time.Now() )
     indefinite: The begin of the animation will be determined by a beginElement() method call or a hyperlink
       targeted to the element.
       (e.g. "infinite")

The attribute value is a semicolon separated list of values. The interpretation of a list of start times is detailed in the SMIL specification in "Evaluation of begin and end time lists". Each individual value can be one of the following: <offset-value>, <syncbase-value>, <event-value>, <repeat-value>, <accessKey-value>, <wallclock-sync-value> or the keyword 'indefinite'.

Português: 

O atributo begin define quando uma animação deve começar ou quando um elemento deve ser descartado.

 Entrada:
   begin: define quando uma animação deve começar ou quando um elemento deve ser descartado.
     offset-value: Esse valor define um valor de relógio que representa um ponto no tempo relativo ao início do
       documento SVG (geralmente o evento load ou DOMContentLoaded). Valores negativos são válidos.
       (e.g. time.Second*5 or "5s")
     syncbase-value: Esse valor define uma base de sincronização e um deslocamento opcional dessa base de
       sincronização. A hora de início da animação do elemento é definida em relação ao início ou fim ativo de outra
       animação.
       Um valor syncbase válido consiste em uma referência de ID para outro elemento de animação seguido por um
       ponto e um início ou fim para identificar se deve ser sincronizado com o início ou o final ativo do elemento
       de animação referenciado. Um valor de deslocamento opcional conforme definido em <offset-value> pode ser
       anexado.
       (e.g. "0s;third.end", "first.end" or "second.end")
     event-value: Esse valor define um evento e um deslocamento opcional que determina a hora em que a animação do
       elemento deve começar. A hora de início da animação é definida em relação à hora em que o evento especificado
       é acionado.
       Um valor de evento válido consiste em um ID de elemento seguido por um ponto e um dos eventos com suporte
       para esse elemento. Todos os eventos válidos (não necessariamente suportados por todos os elementos) são
       definidos pelas especificações DOM e HTML. Esses valores são: 'focus', 'blur', 'focusin', 'focusout',
       'activate', 'auxclick', 'click', 'dblclick', 'mousedown', 'mouseenter', 'mouseleave', 'mousemove',
       'mouseout', 'mouseover', 'mouseup', 'wheel', 'beforeinput', 'input', 'keydown', 'keyup', 'compositionstart',
       'compositionupdate', 'compositionend', 'load', 'unload', 'abort', 'error', 'select', 'resize', 'scroll',
       'beginEvent', 'endEvent', e 'repeatEvent'. Um valor de deslocamento opcional conforme definido em
       <offset-value> pode ser anexado.
       (e.g. "startButton.click")
     repeat-value: Esse valor define um evento de repetição qualificado. A hora de início da animação do elemento é
       definida em relação à hora em que o evento de repetição é gerado com o valor de iteração especificado.
       Um valor de repetição válido consiste em um ID de elemento seguido por um ponto e a função repeat() com um
       valor inteiro especificando o número de repetições como parâmetro. Um valor de deslocamento opcional conforme
       definido em <offset-value> pode ser anexado.
       (e.g. "0s;myLoop.end", "myLoop.begin", "myLoop.repeat(1)" or "myLoop.repeat(2)")
     accessKey-value: Este valor define uma chave de acesso que deve acionar a animação. A animação do elemento
       começará quando o usuário pressionar a tecla especificada.
       Um valor válido de accessKey consiste na função accessKey() com o caractere a ser inserido como parâmetro.
       Um valor de deslocamento opcional conforme definido em <valor de deslocamento> pode ser anexado.
       (e.g. "accessKey(s)")
     wallclock-sync-value: Esse valor define a hora de início da animação como uma hora do relógio do mundo real.
       Um valor wallclock-sync válido consiste na função wallclock() com um valor de tempo como parâmetro. A sintaxe
       de tempo é baseada na sintaxe definida na ISO 8601.
       (e.g. time.Now() )
     indefinite: O início da animação será determinado por uma chamada de método beginElement() ou um hiperlink
       direcionado ao elemento.
       (e.g. "infinite")

O valor do atributo é uma lista de valores separados por ponto e vírgula. A interpretação de uma lista de horários de início é detalhada na especificação SMIL em "Avaliação de listas de horários de início e término". Cada valor individual pode ser um dos seguintes: <offset-value>, <syncbase-value>, <event-value>, <repeat-value>, <accessKey-value>, <wallclock-sync-value> ou a palavra-chave 'indefinite'.

func (*TagSvgGlobal) Bias 

func (e *TagSvgGlobal) Bias(bias float64) (ref *TagSvgGlobal)

Bias

English: 

The bias attribute shifts the range of the filter. After applying the kernelMatrix of the <feConvolveMatrix> element
to the input image to yield a number and applied the divisor attribute, the bias attribute is added to each
component. This allows representation of values that would otherwise be clamped to 0 or 1.

 Input:
   bias: shifts the range of the filter

Português: 

O atributo bias muda o intervalo do filtro. Depois de aplicar o kernelMatrix do elemento <feConvolveMatrix> à imagem
de entrada para gerar um número e aplicar o atributo divisor, o atributo bias é adicionado a cada componente. Isso
permite a representação de valores que de outra forma seriam fixados em 0 ou 1.

 Entrada:
   bias: muda o intervalo do filtro

func (*TagSvgGlobal) By 

func (e *TagSvgGlobal) By(by float64) (ref *TagSvgGlobal)

By

English: 

The by attribute specifies a relative offset value for an attribute that will be modified during an animation.

 Input:
   by: specifies a relative offset value for an attribute

The starting value for the attribute is either indicated by specifying it as value for the attribute given in the attributeName or the from attribute.

Português: 

O atributo by especifica um valor de deslocamento relativo para um atributo que será modificado durante uma
animação.

 Entrada:
   by: especifica um valor de deslocamento relativo para um atributo

O valor inicial para o atributo é indicado especificando-o como valor para o atributo fornecido no attributeName ou no atributo from.

func (*TagSvgGlobal) CalcMode 

func (e *TagSvgGlobal) CalcMode(value interface{}) (ref *TagSvgGlobal)

CalcMode

English: 

The calcMode attribute specifies the interpolation mode for the animation.

 Input:
   KSvgCalcModeDiscrete: This specifies that the animation function will jump from one value to the next without
     any interpolation.
   KSvgCalcModeLinear: Simple linear interpolation between values is used to calculate the animation function.
     Except for <animateMotion>, this is the default value.
   KSvgCalcModePaced: Defines interpolation to produce an even pace of change across the animation.
   KSvgCalcModeSpline: Interpolates from one value in the values list to the next according to a time function
     defined by a cubic Bézier spline. The points of the spline are defined in the keyTimes attribute, and the
     control points for each interval are defined in the keySplines attribute.

The default mode is linear, however if the attribute does not support linear interpolation (e.g. for strings), the calcMode attribute is ignored and discrete interpolation is used. 

Notes:
  Default value: KSvgCalcModePaced

Português: 

O atributo calcMode especifica o modo de interpolação para a animação.

 Entrada:
   KSvgCalcModeDiscrete: Isso especifica que a função de animação saltará de um valor para o próximo sem qualquer
     interpolação.
   KSvgCalcModeLinear: A interpolação linear simples entre valores é usada para calcular a função de animação.
     Exceto para <animateMotion>, este é o valor padrão.
   KSvgCalcModePaced: Define a interpolação para produzir um ritmo uniforme de mudança na animação.
   KSvgCalcModeSpline: Interpola de um valor na lista de valores para o próximo de acordo com uma função de tempo
     definida por uma spline de Bézier cúbica. Os pontos do spline são definidos no atributo keyTimes e os pontos
     de controle para cada intervalo são definidos no atributo keySplines.

O modo padrão é linear, no entanto, se o atributo não suportar interpolação linear (por exemplo, para strings), o atributo calcMode será ignorado e a interpolação discreta será usada. 

Notas:
  * Valor padrão: KSvgCalcModePaced

func (*TagSvgGlobal) Class 

func (e *TagSvgGlobal) Class(class string) (ref *TagSvgGlobal)

Class #styling

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgGlobal) ClipPath 

func (e *TagSvgGlobal) ClipPath(clipPath string) (ref *TagSvgGlobal)

ClipPath #presentation

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgGlobal) ClipPathUnits 

func (e *TagSvgGlobal) ClipPathUnits(value interface{}) (ref *TagSvgGlobal)

ClipPathUnits

English: 

The clipPathUnits attribute indicates which coordinate system to use for the contents of the <clipPath> element.

 Input:
   clipPathUnits: indicates which coordinate system to used
     KSvgClipPathUnits... (e.g. KSvgClipPathUnitsUserSpaceOnUse)

Português: 

O atributo clipPathUnits indica qual sistema de coordenadas deve ser usado para o conteúdo do elemento <clipPath>.

 Input:
   clipPathUnits: indica qual sistema de coordenadas deve ser usado
     KSvgClipPathUnits... (ex. KSvgClipPathUnitsUserSpaceOnUse)

func (*TagSvgGlobal) ClipRule 

func (e *TagSvgGlobal) ClipRule(value interface{}) (ref *TagSvgGlobal)

ClipRule #presentation

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgGlobal) Color 

func (e *TagSvgGlobal) Color(value interface{}) (ref *TagSvgGlobal)

Color #presentation

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgGlobal) ColorInterpolation 

func (e *TagSvgGlobal) ColorInterpolation(value interface{}) (ref *TagSvgGlobal)

ColorInterpolation #presentation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgGlobal) ColorInterpolationFilters 

func (e *TagSvgGlobal) ColorInterpolationFilters(value interface{}) (ref *TagSvgGlobal)

ColorInterpolationFilters #presentation

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgGlobal) CrossOrigin 

func (e *TagSvgGlobal) CrossOrigin(crossOrigin SvgCrossOrigin) (ref *TagSvgGlobal)

CrossOrigin

English: 

The crossorigin attribute, valid on the <image> element, provides support for CORS, defining how the element handles
crossorigin requests, thereby enabling the configuration of the CORS requests for the element's fetched data. It is
a CORS settings attribute.

Português: 

The crossorigin attribute, valid on the <image> element, provides support for CORS, defining how the element handles
crossorigin requests, thereby enabling the configuration of the CORS requests for the element's fetched data. It is
a CORS settings attribute.

func (*TagSvgGlobal) Cursor 

func (e *TagSvgGlobal) Cursor(cursor SvgCursor) (ref *TagSvgGlobal)

Cursor #presentation

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgGlobal) Cx 

func (e *TagSvgGlobal) Cx(value interface{}) (ref *TagSvgGlobal)

Cx

English: 

The cx attribute define the x-axis coordinate of a center point.

 Input:
   value: define the x-axis coordinate
     float32: 0.05 = "5%"
     any other type: interface{}

Português: 

O atributo cx define a coordenada do eixo x de um ponto central.

 Entrada:
   value: define a coordenada do eixo x
     float32: 0.05 = "5%"
     qualquer outro tipo: interface{}

func (*TagSvgGlobal) Cy 

func (e *TagSvgGlobal) Cy(value interface{}) (ref *TagSvgGlobal)

Cy

English:

The cy attribute define the y-axis coordinate of a center point. 

Input:
  value: define the y-axis coordinate
    float32: 0.05 = "5%"
    any other type: interface{}

Português: 

O atributo cy define a coordenada do eixo y de um ponto central.

 Entrada:
   value: define a coordenada do eixo y
     float32: 0.05 = "5%"
     qualquer outro tipo: interface{}

func (*TagSvgGlobal) D 

func (e *TagSvgGlobal) D(d interface{}) (ref *TagSvgGlobal)

D #presentation

English: 

The d attribute defines a path to be drawn.

 d: path to be drawn
   *SvgPath: factoryBrowser.NewPath().M(0, 10).Hd(5).Vd(-9).Hd(12).Vd(9).Hd(5).Vd(16).Hd(-22).Z()
   any other type: interface{}

A path definition is a list of path commands where each command is composed of a command letter and numbers that represent the command parameters. The commands are detailed below.

You can use this attribute with the following SVG elements: <path>, <glyph>, <missing-glyph>.

d is a presentation attribute, and hence can also be used as a CSS property.

Português: 

O atributo d define um caminho a ser desenhado.

 d: caminho a ser desenhado
   *SvgPath: factoryBrowser.NewPath().M(0, 10).Hd(5).Vd(-9).Hd(12).Vd(9).Hd(5).Vd(16).Hd(-22).Z()
   qualquer outro tipo: interface{}

Uma definição de caminho é uma lista de comandos de caminho em que cada comando é composto por uma letra de comando e números que representam os parâmetros do comando. Os comandos são detalhados abaixo.

Você pode usar este atributo com os seguintes elementos SVG: <path>, <glyph>, <missing-glyph>.

d é um atributo de apresentação e, portanto, também pode ser usado como uma propriedade CSS.

func (*TagSvgGlobal) DiffuseConstant 

func (e *TagSvgGlobal) DiffuseConstant(diffuseConstant float64) (ref *TagSvgGlobal)

DiffuseConstant

English: 

The diffuseConstant attribute represents the kd value in the Phong lighting model. In SVG, this can be any
non-negative number.

It's used to determine the final RGB value of a given pixel. The brighter the lighting-color, the smaller this number should be.

Português: 

O atributo difusoConstant representa o valor kd no modelo de iluminação Phong. Em SVG, pode ser qualquer número
não negativo.

É usado para determinar o valor RGB final de um determinado pixel. Quanto mais brilhante a cor da iluminação, menor deve ser esse número.

func (*TagSvgGlobal) Direction 

func (e *TagSvgGlobal) Direction(direction SvgDirection) (ref *TagSvgGlobal)

Direction #presentation

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgGlobal) Display 

func (e *TagSvgGlobal) Display(value interface{}) (ref *TagSvgGlobal)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgGlobal) Divisor 

func (e *TagSvgGlobal) Divisor(divisor float64) (ref *TagSvgGlobal)

Divisor

English: 

The divisor attribute specifies the value by which the resulting number of applying the kernelMatrix of a
<feConvolveMatrix> element to the input image color value is divided to yield the destination color value.

 Input:
   divisor: specifies the divisor value to apply to the original color

A divisor that is the sum of all the matrix values tends to have an evening effect on the overall color intensity of the result.

Português: 

O atributo divisor especifica o valor pelo qual o número resultante da aplicação do kernelMatrix de um elemento
<feConvolveMatrix> ao valor da cor da imagem de entrada é dividido para gerar o valor da cor de destino.

 Entrada:
   divisor: especifica o valor do divisor a ser aplicado na cor original

A divisor that is the sum of all the matrix values tends to have an evening effect on the overall color intensity of the result.

func (*TagSvgGlobal) DominantBaseline 

func (e *TagSvgGlobal) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgGlobal)

DominantBaseline #presentation

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgGlobal) Dur 

func (e *TagSvgGlobal) Dur(dur interface{}) (ref *TagSvgGlobal)

Dur

English: 

The dur attribute indicates the simple duration of an animation.

 Input:
   dur: indicates the simple duration of an animation.
     KSvgDur... (e.g. KSvgDurIndefinite)
     time.Duration (e.g. time.Second * 5)

 Notes:
   * The interpolation will not work if the simple duration is indefinite (although this may still be useful for
     <set> elements).

Português: 

O atributo dur indica a duração simples de uma animação.

 Entrada:
   dur: indica a duração simples de uma animação.
     KSvgDur... (ex. KSvgDurIndefinite)
     time.Duration (ex. time.Second * 5)

 Notas:
   * A interpolação não funcionará se a duração simples for indefinida (embora isso ainda possa ser útil para
     elementos <set>).

func (*TagSvgGlobal) Dx 

func (e *TagSvgGlobal) Dx(value interface{}) (ref *TagSvgGlobal)

Dx

English: 

The dx attribute indicates a shift along the x-axis on the position of an element or its content.

 Input:
   dx: indicates a shift along the x-axis on the position of an element or its content.
     []float32: []float64{0.0, 0.1} = "0% 10%"
     []float64: []float64{0.0, 10.0} = "0 10"
     float32: 0.1 = "10%"
     float64: 10.0 = "10"
     any other type: interface{}

Portuguese 

O atributo dx indica um deslocamento ao longo do eixo x na posição de um elemento ou seu conteúdo.

 Entrada:
   dx: indica um deslocamento ao longo do eixo x na posição de um elemento ou seu conteúdo.
     []float32: []float64{0.0, 0.1} = "0% 10%"
     []float64: []float64{0.0, 10.0} = "0 10"
     float32: 0.1 = "10%"
     float64: 10.0 = "10"
     qualquer outro tipo: interface{}

func (*TagSvgGlobal) Dy 

func (e *TagSvgGlobal) Dy(value interface{}) (ref *TagSvgGlobal)

Dy

English: 

The dy attribute indicates a shift along the y-axis on the position of an element or its content.

 Input:
   dy: indicates a shift along the y-axis on the position of an element or its content.
     []float32: []float64{0.0, 0.1} = "0% 10%"
     []float64: []float64{0.0, 10.0} = "0 10"
     float32: 0.1 = "10%"
     float64: 10.0 = "10"
     any other type: interface{}

Portuguese 

O atributo dy indica um deslocamento ao longo do eixo y na posição de um elemento ou seu conteúdo.

 Entrada:
   dy: indica um deslocamento ao longo do eixo y na posição de um elemento ou seu conteúdo.
     []float32: []float64{0.0, 0.1} = "0% 10%"
     []float64: []float64{0.0, 10.0} = "0 10"
     float32: 0.1 = "10%"
     float64: 10.0 = "10"
     qualquer outro tipo: interface{}

func (*TagSvgGlobal) EdgeMode 

func (e *TagSvgGlobal) EdgeMode(edgeMode SvgEdgeMode) (ref *TagSvgGlobal)

EdgeMode

English: 

The edgeMode attribute determines how to extend the input image as necessary with color values so that the matrix
operations can be applied when the kernel is positioned at or near the edge of the input image.

Portuguese 

O atributo edgeMode determina como estender a imagem de entrada conforme necessário com valores de cor para que as
operações de matriz possam ser aplicadas quando o kernel estiver posicionado na borda da imagem de entrada ou
próximo a ela.

func (*TagSvgGlobal) Elevation 

func (e *TagSvgGlobal) Elevation(elevation float64) (ref *TagSvgGlobal)

Elevation

English: 

The elevation attribute specifies the direction angle for the light source from the XY plane towards the Z-axis, in
degrees. Note that the positive Z-axis points towards the viewer of the content.

Portuguese 

O atributo de elevação especifica o ângulo de direção da fonte de luz do plano XY em direção ao eixo Z, em graus.
Observe que o eixo Z positivo aponta para o visualizador do conteúdo.

func (*TagSvgGlobal) End 

func (e *TagSvgGlobal) End(end interface{}) (ref *TagSvgGlobal)

End

English: 

The end attribute defines an end value for the animation that can constrain the active duration.

 Input:
   end: defines an end value for the animation
     offset-value: This value defines a clock-value that represents a point in time relative to the beginning of the
       SVG document (usually the load or DOMContentLoaded event). Negative values are valid.
       (e.g. time.Second*5 or "5s")
     syncbase-value: This value defines a syncbase and an optional offset from that syncbase. The element's
       animation start time is defined relative to the begin or active end of another animation.
       A valid syncbase-value consists of an ID reference to another animation element followed by a dot and either
       begin or end to identify whether to synchronize with the beginning or active end of the referenced animation
       element. An optional offset value as defined in <offset-value> can be appended.
       (e.g. "0s;third.end", "first.end" or "second.end")
     event-value: This value defines an event and an optional offset that determines the time at which the element's
       animation should begin. The animation start time is defined relative to the time that the specified event is
       fired.
       A valid event-value consists of an element ID followed by a dot and one of the supported events for that
       element. All valid events (not necessarily supported by all elements) are defined by the DOM and HTML
       specifications. Those are: 'focus', 'blur', 'focusin', 'focusout', 'activate', 'auxclick', 'click',
       'dblclick', 'mousedown', 'mouseenter', 'mouseleave', 'mousemove', 'mouseout', 'mouseover', 'mouseup',
       'wheel', 'beforeinput', 'input', 'keydown', 'keyup', 'compositionstart', 'compositionupdate',
       'compositionend', 'load', 'unload', 'abort', 'error', 'select', 'resize', 'scroll', 'beginEvent', 'endEvent',
       and 'repeatEvent'. An optional offset value as defined in <offset-value> can be appended.
       (e.g. "startButton.click")
     repeat-value: This value defines a qualified repeat event. The element animation start time is defined relative
       to the time that the repeat event is raised with the specified iteration value.
       A valid repeat value consists of an element ID followed by a dot and the function repeat() with an integer
       value specifying the number of repetitions as parameter. An optional offset value as defined in
       <offset-value> can be appended.
       (e.g. "0s;myLoop.end", "myLoop.begin", "myLoop.repeat(1)" or "myLoop.repeat(2)")
     accessKey-value: This value defines an access key that should trigger the animation. The element animation will
       begin when the user presses the specified key.
       A valid accessKey-value consists of the function accessKey() with the character to be input as parameter. An
       optional offset value as defined in <offset-value> can be appended.
       (e.g. "accessKey(s)")
     wallclock-sync-value: This value defines the animation start time as a real-world clock time.
       A valid wallclock-sync-value consists of the function wallclock() with a time value as parameter. The time
       syntax is based upon the syntax defined in ISO 8601.
       (e.g. time.Now() )
     indefinite: The begin of the animation will be determined by a beginElement() method call or a hyperlink
       targeted to the element.
       (e.g. "infinite")

Portuguese 

O atributo final define um valor final para a animação que pode restringir a duração ativa.

 Entrada:
   end: define um valor final para a animação
     offset-value: Esse valor define um valor de relógio que representa um ponto no tempo relativo ao início do
       documento SVG (geralmente o evento load ou DOMContentLoaded). Valores negativos são válidos.
       (e.g. time.Second*5 or "5s")
     syncbase-value: Esse valor define uma base de sincronização e um deslocamento opcional dessa base de
       sincronização. A hora de início da animação do elemento é definida em relação ao início ou fim ativo de outra
       animação.
       Um valor syncbase válido consiste em uma referência de ID para outro elemento de animação seguido por um
       ponto e um início ou fim para identificar se deve ser sincronizado com o início ou o final ativo do elemento
       de animação referenciado. Um valor de deslocamento opcional conforme definido em <offset-value> pode ser
       anexado.
       (e.g. "0s;third.end", "first.end" or "second.end")
     event-value: Esse valor define um evento e um deslocamento opcional que determina a hora em que a animação do
       elemento deve começar. A hora de início da animação é definida em relação à hora em que o evento especificado
       é acionado.
       Um valor de evento válido consiste em um ID de elemento seguido por um ponto e um dos eventos com suporte
       para esse elemento. Todos os eventos válidos (não necessariamente suportados por todos os elementos) são
       definidos pelas especificações DOM e HTML. Esses valores são: 'focus', 'blur', 'focusin', 'focusout',
       'activate', 'auxclick', 'click', 'dblclick', 'mousedown', 'mouseenter', 'mouseleave', 'mousemove',
       'mouseout', 'mouseover', 'mouseup', 'wheel', 'beforeinput', 'input', 'keydown', 'keyup', 'compositionstart',
       'compositionupdate', 'compositionend', 'load', 'unload', 'abort', 'error', 'select', 'resize', 'scroll',
       'beginEvent', 'endEvent', e 'repeatEvent'. Um valor de deslocamento opcional conforme definido em
       <offset-value> pode ser anexado.
       (e.g. "startButton.click")
     repeat-value: Esse valor define um evento de repetição qualificado. A hora de início da animação do elemento é
       definida em relação à hora em que o evento de repetição é gerado com o valor de iteração especificado.
       Um valor de repetição válido consiste em um ID de elemento seguido por um ponto e a função repeat() com um
       valor inteiro especificando o número de repetições como parâmetro. Um valor de deslocamento opcional conforme
       definido em <offset-value> pode ser anexado.
       (e.g. "0s;myLoop.end", "myLoop.begin", "myLoop.repeat(1)" or "myLoop.repeat(2)")
     accessKey-value: Este valor define uma chave de acesso que deve acionar a animação. A animação do elemento
       começará quando o usuário pressionar a tecla especificada.
       Um valor válido de accessKey consiste na função accessKey() com o caractere a ser inserido como parâmetro.
       Um valor de deslocamento opcional conforme definido em <valor de deslocamento> pode ser anexado.
       (e.g. "accessKey(s)")
     wallclock-sync-value: Esse valor define a hora de início da animação como uma hora do relógio do mundo real.
       Um valor wallclock-sync válido consiste na função wallclock() com um valor de tempo como parâmetro. A sintaxe
       de tempo é baseada na sintaxe definida na ISO 8601.
       (e.g. time.Now() )
     indefinite: O início da animação será determinado por uma chamada de método beginElement() ou um hiperlink
       direcionado ao elemento.
       (e.g. "infinite")

func (*TagSvgGlobal) Exponent 

func (e *TagSvgGlobal) Exponent(exponent float64) (ref *TagSvgGlobal)

Exponent

English: 

The exponent attribute defines the exponent of the gamma function.

Portuguese 

O atributo expoente define o expoente da função gama.

func (*TagSvgGlobal) Fill 

func (e *TagSvgGlobal) Fill(value interface{}) (ref *TagSvgGlobal)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgGlobal) FillOpacity 

func (e *TagSvgGlobal) FillOpacity(value interface{}) (ref *TagSvgGlobal)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgGlobal) FillRule 

func (e *TagSvgGlobal) FillRule(fillRule SvgFillRule) (ref *TagSvgGlobal)

FillRule #presentation

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgGlobal) Filter 

func (e *TagSvgGlobal) Filter(filter string) (ref *TagSvgGlobal)

Filter #presentation

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgGlobal) FilterUnits 

func (e *TagSvgGlobal) FilterUnits(filterUnits SvgFilterUnits) (ref *TagSvgGlobal)

FilterUnits

English: 

The filterUnits attribute defines the coordinate system for the attributes x, y, width and height.

Portuguese 

O atributo filterUnits define o sistema de coordenadas para os atributos x, y, largura e altura.

func (*TagSvgGlobal) FloodColor 

func (e *TagSvgGlobal) FloodColor(floodColor interface{}) (ref *TagSvgGlobal)

FloodColor #presentation

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgGlobal) FloodOpacity 

func (e *TagSvgGlobal) FloodOpacity(floodOpacity float64) (ref *TagSvgGlobal)

FloodOpacity #presentation

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgGlobal) FontFamily 

func (e *TagSvgGlobal) FontFamily(fontFamily string) (ref *TagSvgGlobal)

FontFamily #presentation

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgGlobal) FontSize 

func (e *TagSvgGlobal) FontSize(fontSize interface{}) (ref *TagSvgGlobal)

FontSize #presentation

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgGlobal) FontSizeAdjust 

func (e *TagSvgGlobal) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgGlobal)

FontSizeAdjust #presentation

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgGlobal) FontStretch 

func (e *TagSvgGlobal) FontStretch(fontStretch interface{}) (ref *TagSvgGlobal)

FontStretch #presentation

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgGlobal) FontStyle 

func (e *TagSvgGlobal) FontStyle(fontStyle FontStyleRule) (ref *TagSvgGlobal)

FontStyle #presentation

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgGlobal) FontVariant 

func (e *TagSvgGlobal) FontVariant(value interface{}) (ref *TagSvgGlobal)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgGlobal) FontWeight 

func (e *TagSvgGlobal) FontWeight(value interface{}) (ref *TagSvgGlobal)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgGlobal) Fr 

func (e *TagSvgGlobal) Fr(fr interface{}) (ref *TagSvgGlobal)

Fr

English: 

The fr attribute defines the radius of the focal point for the radial gradient.

 Input:
   fr: defines the radius of the focal point for the radial gradient
     float32: (e.g. 0.4 = 40%)
     string: "40%"

Portuguese 

O atributo fr define o raio do ponto focal para o gradiente radial.

 Entrada:
   fr: define o raio do ponto focal para o gradiente radial.
     float32: (ex. 0.4 = 40%)
     string: "40%"

func (*TagSvgGlobal) From 

func (e *TagSvgGlobal) From(value interface{}) (ref *TagSvgGlobal)

From

English:

The from attribute indicates the initial value of the attribute that will be modified during the animation. 

Input:
  value: initial value of the attribute
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1),rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0%, 10%"
    []float64: []float64{0.0, 10.0} = "0, 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s, 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    any other type: interface{}

When used with the to attribute, the animation will change the modified attribute from the from value to the to value. When used with the by attribute, the animation will change the attribute relatively from the from value by the value specified in by.

Português:

O atributo from indica o valor inicial do atributo que será modificado durante a animação. 

Entrada:
  value: valor inicial do atributo
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1),rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0%, 10%"
    []float64: []float64{0.0, 10.0} = "0, 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s, 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    qualquer outro tipo: interface{}

Quando usado com o atributo to, a animação mudará o atributo modificado do valor from para o valor to. Quando usado com o atributo by, a animação mudará o atributo relativamente do valor from pelo valor especificado em by.

func (*TagSvgGlobal) Fx 

func (e *TagSvgGlobal) Fx(value interface{}) (ref *TagSvgGlobal)

Fx

English: 

The fx attribute defines the x-axis coordinate of the focal point for a radial gradient.
   value: the x-axis coordinate of the focal point for a radial gradient
     float32: 1.0 = "100%"
     any other type: interface{}

Portuguese 

O atributo fx define a coordenada do eixo x do ponto focal para um gradiente radial.
   value: coordenada do eixo x do ponto focal para um gradiente radial
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

func (*TagSvgGlobal) Fy 

func (e *TagSvgGlobal) Fy(value interface{}) (ref *TagSvgGlobal)

Fy

English: 

The fy attribute defines the y-axis coordinate of the focal point for a radial gradient.

 Input:
   value: the y-axis coordinate of the focal point for a radial gradient
     float32: 1.0 = "100%"
     any other type: interface{}

Portuguese 

O atributo fy define a coordenada do eixo y do ponto focal para um gradiente radial.

 Entrada:
   value: coordenada do eixo y do ponto focal para um gradiente radial
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

func (*TagSvgGlobal) GradientTransform 

func (e *TagSvgGlobal) GradientTransform(value interface{}) (ref *TagSvgGlobal)

GradientTransform

English: 

The gradientTransform attribute contains the definition of an optional additional transformation from the gradient
coordinate system onto the target coordinate system (i.e., userSpaceOnUse or objectBoundingBox).

 Input:
   value: definition of an optional additional transformation from the gradient coordinate system
     Object: &html.TransformFunctions{}
     any other type: interface{}

This allows for things such as skewing the gradient. This additional transformation matrix is post-multiplied to
(i.e., inserted to the right of) any previously defined transformations, including the implicit transformation
necessary to convert from object bounding box units to user space.

Portuguese 

O atributo gradientTransform contém a definição de uma transformação adicional opcional do sistema de coordenadas
de gradiente para o sistema de coordenadas de destino (ou seja, userSpaceOnUse ou objectBoundingBox).

 Entrada:
   value: definição de uma transformação adicional opcional do sistema de coordenadas de gradiente
     Object: &html.TransformFunctions{}
     qualquer outro tipo: interface{}

Isso permite coisas como distorcer o gradiente. Essa matriz de transformação adicional é pós-multiplicada para
(ou seja, inserida à direita de) quaisquer transformações definidas anteriormente, incluindo a transformação
implícita necessária para converter de unidades de caixa delimitadora de objeto para espaço do usuário.

func (*TagSvgGlobal) GradientUnits 

func (e *TagSvgGlobal) GradientUnits(value interface{}) (ref *TagSvgGlobal)

GradientUnits

English: 

The gradientUnits attribute defines the coordinate system used for attributes specified on the gradient elements.

 Input:
   value: defines the coordinate system
     const: KSvgGradientUnits... (e.g. KSvgGradientUnitsUserSpaceOnUse)
     any other type: interface{}

Portuguese 

O atributo gradientUnits define o sistema de coordenadas usado para atributos especificados nos elementos
gradientes.

 Entrada:
   value: define o sistema de coordenadas
     const: KSvgGradientUnits... (ex. KSvgGradientUnitsUserSpaceOnUse)
     any other type: interface{}

func (*TagSvgGlobal) HRef 

func (e *TagSvgGlobal) HRef(href string) (ref *TagSvgGlobal)

HRef

English: 

The href attribute defines a link to a resource as a reference URL. The exact meaning of that link depends on the
context of each element using it.

 Notes:
   * Specifications before SVG 2 defined an xlink:href attribute, which is now rendered obsolete by the href
     attribute.
     If you need to support earlier browser versions, the deprecated xlink:href attribute can be used as a fallback
     in addition to the href attribute, e.g. <use href="some-id" xlink:href="some-id x="5" y="5" />.

Português: 

O atributo href define um link para um recurso como um URL de referência. O significado exato desse link depende do
contexto de cada elemento que o utiliza.

 Notas:
   * As especificações anteriores ao SVG 2 definiam um atributo xlink:href, que agora se torna obsoleto pelo
     atributo href.
     Se você precisar oferecer suporte a versões anteriores do navegador, o atributo obsoleto xlink:href pode ser
     usado como um substituto além do atributo href, por exemplo,
     <use href="some-id" xlink:href="some-id x="5" y="5" />.

func (*TagSvgGlobal) Height 

func (e *TagSvgGlobal) Height(height interface{}) (ref *TagSvgGlobal)

Height

English: 

The height attribute defines the vertical length of an element in the user coordinate system.
     float32: 1.0 = "100%"
     any other type: interface{}

Português: 

O atributo height define o comprimento vertical de um elemento no sistema de coordenadas do usuário.
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

func (*TagSvgGlobal) Id 

func (e *TagSvgGlobal) Id(id string) (ref *TagSvgGlobal)

Id #core

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgGlobal) ImageRendering 

func (e *TagSvgGlobal) ImageRendering(imageRendering string) (ref *TagSvgGlobal)

ImageRendering #presentation

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgGlobal) In 

func (e *TagSvgGlobal) In(in interface{}) (ref *TagSvgGlobal)

In

English: 

The in attribute identifies input for the given filter primitive.

 Input:
   in: identifies input for the given filter primitive.
     KSvgIn... (e.g. KSvgInSourceAlpha)
     any other type: interface{}

The value can be either one of the six keywords defined below, or a string which matches a previous result attribute value within the same <filter> element. If no value is provided and this is the first filter primitive, then this filter primitive will use SourceGraphic as its input. If no value is provided and this is a subsequent filter primitive, then this filter primitive will use the result from the previous filter primitive as its input.

If the value for result appears multiple times within a given <filter> element, then a reference to that result will use the closest preceding filter primitive with the given value for attribute result.

Portuguese 

O atributo in identifica à entrada para a primitiva de filtro fornecida.

 Entrada:
   in: identifica à entrada para a primitiva de filtro fornecida.
     KSvgIn... (e.g. KSvgInSourceAlpha)
     qualquer outro tipo: interface{}

O valor pode ser uma das seis palavras-chave definidas abaixo ou uma string que corresponda a um valor de atributo de resultado anterior dentro do mesmo elemento <filter>. Se nenhum valor for fornecido e esta for a primeira primitiva de filtro, essa primitiva de filtro usará SourceGraphic como sua entrada. Se nenhum valor for fornecido e esta for uma primitiva de filtro subsequente, essa primitiva de filtro usará o resultado da primitiva de filtro anterior como sua entrada.

Se o valor do resultado aparecer várias vezes em um determinado elemento <filter>, uma referência à esse resultado usará a primitiva de filtro anterior mais próxima com o valor fornecido para o resultado do atributo.

func (*TagSvgGlobal) In2 

func (e *TagSvgGlobal) In2(in2 interface{}) (ref *TagSvgGlobal)

In2

English: 

The in2 attribute identifies the second input for the given filter primitive. It works exactly like the in
attribute.

 Input:
   in2: identifies the second input for the given filter primitive.
     KSvgIn2... (e.g. KSvgIn2SourceAlpha)
     string: url(#myClip)
     any other type: interface{}

Portuguese 

O atributo in2 identifica a segunda entrada para a primitiva de filtro fornecida. Funciona exatamente como o
atributo in.

 Entrada:
   in2: identifica a segunda entrada para a primitiva de filtro fornecida.
     KSvgIn2... (ex. KSvgIn2SourceAlpha)
     string: url(#myClip)
     qualquer outro tipo: interface{}

func (*TagSvgGlobal) Intercept 

func (e *TagSvgGlobal) Intercept(intercept float64) (ref *TagSvgGlobal)

Intercept

English: 

The intercept attribute defines the intercept of the linear function of color component transfers when the type
attribute is set to linear.

Portuguese 

O atributo de interceptação define a interceptação da função linear de transferências de componentes de cor quando
o atributo de tipo é definido como linear.

func (*TagSvgGlobal) K1 

func (e *TagSvgGlobal) K1(k1 float64) (ref *TagSvgGlobal)

K1

English: 

The k1 attribute defines one of the values to be used within the arithmetic operation of the <feComposite>
filter primitive.

The pixel composition is computed using the following formula: 

result = k1*i1*i2 + k2*i1 + k3*i2 + k4

Portuguese 

O atributo k1 define um dos valores a serem usados na operação aritmética da primitiva de filtro <feComposite>.

A composição de pixels é calculada usando a seguinte fórmula: 

result = k1*i1*i2 + k2*i1 + k3*i2 + k4

func (*TagSvgGlobal) K2 

func (e *TagSvgGlobal) K2(k2 float64) (ref *TagSvgGlobal)

K2

English: 

The k2 attribute defines one of the values to be used within the arithmetic operation of the <feComposite> filter
primitive.

The pixel composition is computed using the following formula: 

result = k1*i1*i2 + k2*i1 + k3*i2 + k4

Portuguese 

O atributo k2 define um dos valores a serem usados na operação aritmética da primitiva de filtro <feComposite>.

A composição de pixels é calculada usando a seguinte fórmula: 

result = k1*i1*i2 + k2*i1 + k3*i2 + k4

func (*TagSvgGlobal) K3 

func (e *TagSvgGlobal) K3(k3 float64) (ref *TagSvgGlobal)

K3

English: 

The k3 attribute defines one of the values to be used within the arithmetic operation of the <feComposite>
filter primitive.

The pixel composition is computed using the following formula: 

result = k1*i1*i2 + k2*i1 + k3*i2 + k4

Portuguese 

O atributo k3 define um dos valores a serem usados na operação aritmética da primitiva de filtro <feComposite>.

A composição de pixels é calculada usando a seguinte fórmula: 

result = k1*i1*i2 + k2*i1 + k3*i2 + k4

func (*TagSvgGlobal) K4 

func (e *TagSvgGlobal) K4(k4 float64) (ref *TagSvgGlobal)

K4

English: 

The k4 attribute defines one of the values to be used within the arithmetic operation of the <feComposite>
filter primitive.

The pixel composition is computed using the following formula: 

result = k1*i1*i2 + k2*i1 + k3*i2 + k4

Portuguese 

O atributo k4 define um dos valores a serem usados na operação aritmética da primitiva de filtro <feComposite>.

A composição de pixels é calculada usando a seguinte fórmula: 

result = k1*i1*i2 + k2*i1 + k3*i2 + k4

func (*TagSvgGlobal) KernelMatrix 

func (e *TagSvgGlobal) KernelMatrix(value interface{}) (ref *TagSvgGlobal)

KernelMatrix

English:

The kernelMatrix attribute defines the list of numbers that make up the kernel matrix for the <feConvolveMatrix> element. 

Input:
  kernelMatrix: list of numbers
    []float64: []float64{1, 1, 0, 0, 0, 0, 0, 0, -1} = "1 1 0 0 0 0 0 0 -1"
    any other type: interface{}

The list of <number>s that make up the kernel matrix for the convolution. The number of entries in the list must equal <orderX> times <orderY>. If the result of orderX * orderY is not equal to the number of entries in the value list, the filter primitive acts as a pass through filter.

Values are separated by space characters and/or a comma. The number of entries in the list must equal to <orderX> by <orderY> as defined in the order attribute.

Português:

O atributo kernelMatrix define a lista de números que compõem a matriz do kernel para o elemento <feConvolveMatrix>. 

Entrada:
  kernelMatrix: lista de números
    []float64: []float64{1, 1, 0, 0, 0, 0, 0, 0, -1} = "1 1 0 0 0 0 0 0 -1"
    any other type: interface{}

A lista de números que compõem a matriz do kernel para a convolução. O número de entradas na lista deve ser igual a <orderX> * <orderY>. Se o resultado da ordem do pedido não for igual ao número de entradas na lista de valores, a primitiva de filtro atua como um filtro de passagem.

Os valores são separados por caracteres de espaço e ou por vírgula. O número de entradas na lista deve ser igual a <orderX> por <orderY> conforme definido no atributo order.

func (*TagSvgGlobal) KeyPoints 

func (e *TagSvgGlobal) KeyPoints(keyPoints []float64) (ref *TagSvgGlobal)

KeyPoints

English:

The keyPoints attribute indicates the simple duration of an animation. 

Input:
  keyPoints: This value defines a semicolon-separated list of floating point values between 0 and 1 and indicates
  how far along the motion path the object shall move at the moment in time specified by corresponding keyTimes
  value. The distance is calculated along the path specified by the path attribute. Each progress value in the list
  corresponds to a value in the keyTimes attribute list.
  If a list of key points is specified, there must be exactly as many values in the keyPoints list as in the
  keyTimes list.
  If there's a semicolon at the end of the value, optionally followed by white space, both the semicolon and the
  trailing white space are ignored.
  If there are any errors in the value specification (i.e. bad values, too many or too few values), then that's
  an error.

Português:

O atributo keyPoints indica a duração simples de uma animação. 

Entrada:
  keyPoints: Este valor define uma lista separada por ponto e vírgula de valores de ponto flutuante entre 0 e 1 e
  indica a distância ao longo do caminho de movimento o objeto deve se mover no momento especificado pelo valor
  keyTimes correspondente. A distância é calculada ao longo do caminho especificado pelo atributo path. Cada valor
  de progresso na lista corresponde a um valor na lista de atributos keyTimes.
  Se uma lista de pontos-chave for especificada, deve haver exatamente tantos valores na lista keyPoints quanto na
  lista keyTimes.
  Se houver um ponto e vírgula no final do valor, opcionalmente seguido por espaço em branco, o ponto e vírgula e
  o espaço em branco à direita serão ignorados.
  Se houver algum erro na especificação do valor (ou seja, valores incorretos, muitos ou poucos valores), isso é
  um erro.

func (*TagSvgGlobal) KeySplines 

func (e *TagSvgGlobal) KeySplines(value interface{}) (ref *TagSvgGlobal)

KeySplines

English:

The keySplines attribute defines a set of Bézier curve control points associated with the keyTimes list, defining a cubic Bézier function that controls interval pacing.

This attribute is ignored unless the calcMode attribute is set to spline.

If there are any errors in the keySplines specification (bad values, too many or too few values), the animation will not occur.

Português:

O atributo keySplines define um conjunto de pontos de controle da curva Bézier associados à lista keyTimes, definindo uma função Bézier cúbica que controla o ritmo do intervalo.

Esse atributo é ignorado, a menos que o atributo calcMode seja definido como spline.

Se houver algum erro na especificação de keySplines (valores incorretos, muitos ou poucos valores), a animação não ocorrerá.

func (*TagSvgGlobal) KeyTimes 

func (e *TagSvgGlobal) KeyTimes(value interface{}) (ref *TagSvgGlobal)

KeyTimes

English:

The keyTimes attribute represents a list of time values used to control the pacing of the animation. 

Input:
  value: list of time values used to control
    []float64{0.0, 0.5, 1.0}: values="0; 0.5; 1"

Each time in the list corresponds to a value in the values attribute list, and defines when the value is used in the animation.

Each time value in the keyTimes list is specified as a floating point value between 0 and 1 (inclusive), representing a proportional offset into the duration of the animation element.

Português:

O atributo keyTimes representa uma lista de valores de tempo usados para controlar o ritmo da animação. 

Entrada:
  value: lista de valores de tempo usados para controle
    []float64{0.0, 0.5, 1.0}: values="0; 0.5; 1"

Cada vez na lista corresponde a um valor na lista de atributos de valores e define quando o valor é usado na animação.

Cada valor de tempo na lista keyTimes é especificado como um valor de ponto flutuante entre 0 e 1 (inclusive), representando um deslocamento proporcional à duração do elemento de animação.

func (*TagSvgGlobal) Lang 

func (e *TagSvgGlobal) Lang(value interface{}) (ref *TagSvgGlobal)

Lang #core

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgGlobal) LengthAdjust 

func (e *TagSvgGlobal) LengthAdjust(value interface{}) (ref *TagSvgGlobal)

LengthAdjust

English:

The lengthAdjust attribute controls how the text is stretched into the length defined by the textLength attribute. 

Input:
  value: controls how the text is stretched
    KSvgLengthAdjust... (e.g. KSvgLengthAdjustSpacing)

Português:

O atributo lengthAdjust controla como o texto é esticado no comprimento definido pelo atributo textLength. 

Input:
  value: controla como o texto é esticado
    KSvgLengthAdjust... (e.g. KSvgLengthAdjustSpacing)

func (*TagSvgGlobal) LetterSpacing 

func (e *TagSvgGlobal) LetterSpacing(value float64) (ref *TagSvgGlobal)

LetterSpacing #presentation

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgGlobal) LightingColor 

func (e *TagSvgGlobal) LightingColor(value interface{}) (ref *TagSvgGlobal)

LightingColor #presentation

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgGlobal) LimitingConeAngle 

func (e *TagSvgGlobal) LimitingConeAngle(value float64) (ref *TagSvgGlobal)

LimitingConeAngle

English:

The limitingConeAngle attribute represents the angle in degrees between the spot light axis (i.e. the axis between the light source and the point to which it is pointing at) and the spot light cone. So it defines a limiting cone which restricts the region where the light is projected. No light is projected outside the cone. 

Input:
  value: represents the angle in degrees between the spot light axis

Português:

O atributo limitConeAngle representa o ângulo em graus entre o eixo de luz spot (ou seja, o eixo entre a fonte de luz e o ponto para o qual está apontando) e o cone de luz spot. Assim, define um cone limitador que restringe a região onde a luz é projetada. Nenhuma luz é projetada fora do cone. 

Input:
  value: representa o ângulo em graus entre o eixo da luz spot

func (*TagSvgGlobal) MarkerEnd 

func (e *TagSvgGlobal) MarkerEnd(value interface{}) (ref *TagSvgGlobal)

MarkerEnd #presentation

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgGlobal) MarkerHeight 

func (e *TagSvgGlobal) MarkerHeight(value interface{}) (ref *TagSvgGlobal)

MarkerHeight

English:

The markerHeight attribute represents the height of the viewport into which the <marker> is to be fitted when it is rendered according to the viewBox and preserveAspectRatio attributes. 

Input:
  value: represents the height of the viewport
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo markerHeight representa a altura da viewport na qual o <marker> deve ser ajustado quando for renderizado de acordo com os atributos viewBox e preserveAspectRatio. 

Entrada:
  value: representa a altura da janela de visualização
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgGlobal) MarkerMid 

func (e *TagSvgGlobal) MarkerMid(value interface{}) (ref *TagSvgGlobal)

MarkerMid #presentation

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgGlobal) MarkerStart 

func (e *TagSvgGlobal) MarkerStart(value interface{}) (ref *TagSvgGlobal)

MarkerStart #presentation

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgGlobal) MarkerUnits 

func (e *TagSvgGlobal) MarkerUnits(value interface{}) (ref *TagSvgGlobal)

MarkerUnits

English:

The markerUnits attribute defines the coordinate system for the markerWidth and markerHeight attributes and the contents of the <marker>. 

Input:
  value: defines the coordinate system
    const KSvgMarkerUnits... (e.g. KSvgMarkerUnitsUserSpaceOnUse)

Português:

O atributo markerUnits define o sistema de coordenadas para os atributos markerWidth e markerHeight e o conteúdo do <marker>. 

Entrada:
  value: define o sistema de coordenadas
    const KSvgMarkerUnits... (ex. KSvgMarkerUnitsUserSpaceOnUse)

func (*TagSvgGlobal) MarkerWidth 

func (e *TagSvgGlobal) MarkerWidth(value interface{}) (ref *TagSvgGlobal)

MarkerWidth

English:

The markerWidth attribute represents the width of the viewport into which the <marker> is to be fitted when it is rendered according to the viewBox and preserveAspectRatio attributes. 

Input:
  value: represents the width of the viewport
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo markerWidth representa a largura da viewport na qual o <marker> deve ser ajustado quando for renderizado de acordo com os atributos viewBox e preserveAspectRatio. 

Input:
  value: representa a largura da janela de visualização
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgGlobal) Mask 

func (e *TagSvgGlobal) Mask(value interface{}) (ref *TagSvgGlobal)

Mask #presentation

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgGlobal) MaskContentUnits 

func (e *TagSvgGlobal) MaskContentUnits(value interface{}) (ref *TagSvgGlobal)

MaskContentUnits

English:

The maskContentUnits attribute indicates which coordinate system to use for the contents of the <mask> element. 

Input:
  value: specifies the coordinate system
    const KSvgUnits... (e.g. KSvgUnitsObjectBoundingBox)
    any other type: interface{}

Português:

O atributo maskContentUnits indica qual sistema de coordenadas usar para o conteúdo do elemento <mask>. 

Entrada:
  value: especifica o sistema de coordenadas
    const KSvgUnits... (e.g. KSvgUnitsObjectBoundingBox)
    qualquer outro tipo: interface{}

func (*TagSvgGlobal) MaskUnits 

func (e *TagSvgGlobal) MaskUnits(value interface{}) (ref *TagSvgGlobal)

MaskUnits

English:

The maskUnits attribute indicates which coordinate system to use for the geometry properties of the <mask> element. 

Input:
  value: specifies the coordinate system
    const KSvgUnits... (e.g. KSvgUnitsObjectBoundingBox)
    any other type: interface{}

Português:

O atributo maskUnits indica qual sistema de coordenadas usar para as propriedades geométricas do elemento <mask>. 

Entrada:
  value: especifica o sistema de coordenadas
    const KSvgUnits... (e.g. KSvgUnitsObjectBoundingBox)
    qualquer outro tipo: interface{}

func (*TagSvgGlobal) Max 

func (e *TagSvgGlobal) Max(value interface{}) (ref *TagSvgGlobal)

Max

English:

The max attribute specifies the maximum value of the active animation duration. 

Input:
  value: specifies the maximum value
    float32: 1.0 = "100%"
    time.Duration: 5*time.Second = "5s"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo max especifica o valor máximo da duração da animação ativa. 

Entrada:
  value: especifica o valor máximo
    float32: 1.0 = "100%"
    time.Duration: 5*time.Second = "5s"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgGlobal) Media 

func (e *TagSvgGlobal) Media(value interface{}) (ref *TagSvgGlobal)

Media

English:

The media attribute specifies a media query that must be matched for a style sheet to apply.

Português:

O atributo de mídia especifica uma consulta de mídia que deve ser correspondida para que uma folha de estilo seja aplicada.

func (*TagSvgGlobal) Min 

func (e *TagSvgGlobal) Min(value interface{}) (ref *TagSvgGlobal)

Min

English:

The min attribute specifies the minimum value of the active animation duration. 

Input:
  value: specifies the minimum value
    float32: 1.0 = "100%"
    time.Duration: 5*time.Second = "5s"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo min especifica o valor mínimo da duração da animação ativa. 

Input:
  value: especifica o valor mínimo
    float32: 1.0 = "100%"
    time.Duration: 5*time.Second = "5s"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgGlobal) Mode 

func (e *TagSvgGlobal) Mode(value interface{}) (ref *TagSvgGlobal)

Mode

English:

The mode attribute defines the blending mode on the <feBlend> filter primitive. 

Input:
  value: defines the blending mode
    const KSvgMode... (e.g. KSvgModeNormal)
    any other type: interface{}

Português:

O atributo mode define o modo de mesclagem na primitiva de filtro <feBlend>. 

Entrada:
  value: define o modo de mesclagem
    const KSvgMode... (ex. KSvgModeNormal)
    qualquer outro tipo: interface{}

todo: exemplos: https://developer.mozilla.org/en-US/docs/Web/CSS/blend-mode

func (*TagSvgGlobal) NumOctaves 

func (e *TagSvgGlobal) NumOctaves(value float64) (ref *TagSvgGlobal)

NumOctaves

English:

The numOctaves attribute defines the number of octaves for the noise function of the <feTurbulence> primitive. 

Input:
  value: defines the number of octaves for the noise function

An octave is a noise function defined by its frequency and amplitude. A turbulence is built by accumulating several octaves with increasing frequencies and decreasing amplitudes. The higher the number of octaves, the more natural the noise looks. Though more octaves also require more calculations, resulting in a negative impact on performance.

Português:

O atributo numOctaves define o número de oitavas para a função de ruído da primitiva <feTurbulence>. 

Input:
  value: define o número de oitavas para a função de ruído

Uma oitava é uma função de ruído definida por sua frequência e amplitude. Uma turbulência é construída acumulando várias oitavas com frequências crescentes e amplitudes decrescentes. Quanto maior o número de oitavas, mais natural o ruído parece. Embora mais oitavas também exijam mais cálculos, resultando em um impacto negativo no desempenho.

func (*TagSvgGlobal) Opacity 

func (e *TagSvgGlobal) Opacity(value interface{}) (ref *TagSvgGlobal)

Opacity #presentation

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgGlobal) Operator 

func (e *TagSvgGlobal) Operator(value interface{}) (ref *TagSvgGlobal)

Operator

English:

The operator attribute has two meanings based on the context it's used in. Either it defines the compositing or morphing operation to be performed. 

Input:
  value: defines the compositing or morphing
    const: KSvgOperatorFeComposite... (e.g. KSvgOperatorFeCompositeOver)
    const: KSvgOperatorFeMorphology... (e.g. KKSvgOperatorFeCompositeErode)

Português:

O atributo operador tem dois significados com base no contexto em que é usado. Ele define a operação de composição ou transformação a ser executada. 

Entrada:
  value: define a composição ou morphing
    const: KSvgOperatorFeComposite... (e.g. KSvgOperatorFeCompositeOver)
    const: KSvgOperatorFeMorphology... (e.g. KKSvgOperatorFeCompositeErode)

fixme: separar quando colocar em <feComposite> e <feMorphology>

func (*TagSvgGlobal) Order 

func (e *TagSvgGlobal) Order(value interface{}) (ref *TagSvgGlobal)

Order

English:

The order attribute indicates the size of the matrix to be used by a <feConvolveMatrix> element. 

Input:
  value: indicates the size of the matrix.
    []float64: []float64{1.0, 1.0, 1.0} = "1 1 1"
    any other type: interface{}

Português:

O atributo order indica o tamanho da matriz a ser usada por um elemento <feConvolveMatrix>. 

Entrada:
  value: indica o tamanho da matriz.
    []float64: []float64{1.0, 1.0, 1.0} = "1 1 1"
    qualquer outro tipo: interface{}

func (*TagSvgGlobal) Orient 

func (e *TagSvgGlobal) Orient(value interface{}) (ref *TagSvgGlobal)

Orient

English:

The orient attribute indicates how a marker is rotated when it is placed at its position on the shape. 

Input:
  value: indicates how a marker is rotated
    const: KSvgOrient... (e.g. KSvgOrientAuto)
    Degrees: Degrees(-65) = "-65deg"
    any other type: interface{}

Português:

O atributo orient indica como um marcador é girado quando é colocado em sua posição na forma. 

Entrada:
  value: indica como um marcador é girado
    const: KSvgOrient... (ex. KSvgOrientAuto)
    Degrees: Degrees(-65) = "-65deg"
    qualquer outro tipo: interface{}

func (*TagSvgGlobal) Origin 

func (e *TagSvgGlobal) Origin(value interface{}) (ref *TagSvgGlobal)

Origin

English:

The origin attribute specifies the origin of motion for an animation. It has no effect in SVG.

Português:

O atributo origin especifica a origem do movimento de uma animação. Não tem efeito em SVG.

func (*TagSvgGlobal) Overflow 

func (e *TagSvgGlobal) Overflow(value interface{}) (ref *TagSvgGlobal)

Overflow #presentation

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgGlobal) OverlinePosition 

func (e *TagSvgGlobal) OverlinePosition(value interface{}) (ref *TagSvgGlobal)

OverlinePosition

English:

The overline-position attribute represents the ideal vertical position of the overline. The overline position is expressed in the font's coordinate system.

Português:

O atributo overline-position representa a posição vertical ideal da overline. A posição sobreposta é expressa no sistema de coordenadas da fonte.

func (*TagSvgGlobal) OverlineThickness 

func (e *TagSvgGlobal) OverlineThickness(value interface{}) (ref *TagSvgGlobal)

OverlineThickness

English:

The overline-thickness attribute represents the ideal thickness of the overline. The overline thickness is expressed in the font's coordinate system.

Português:

O atributo overline-thickness representa a espessura ideal da overline. A espessura do overline é expressa no sistema de coordenadas da fonte.

func (*TagSvgGlobal) PaintOrder 

func (e *TagSvgGlobal) PaintOrder(value interface{}) (ref *TagSvgGlobal)

PaintOrder

English:

The paint-order attribute specifies the order that the fill, stroke, and markers of a given shape or text element are painted. 

Input:
  value: specifies the order that the fill, stroke, and markers
    const: SvgPaintOrder... (e.g. KSvgPaintOrderStroke)
    any other type: interface{}

Notes:
  * As a presentation attribute, paint-order can be used as a CSS property.

Português:

O atributo paint-order especifica a ordem em que o preenchimento, o traçado e os marcadores de uma determinada forma ou elemento de texto são pintados. 

Entrada:
  value: especifica a ordem em que o preenchimento, o traçado e os marcadores
    const: SvgPaintOrder... (e.g. KSvgPaintOrderStroke)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, paint-order pode ser usado como uma propriedade CSS.

func (*TagSvgGlobal) Path 

func (e *TagSvgGlobal) Path(value *SvgPath) (ref *TagSvgGlobal)

Path

English:

The path attribute has two different meanings, either it defines a text path along which the characters of a text are rendered, or a motion path along which a referenced element is animated.

Português:

O atributo path tem dois significados diferentes: define um caminho de texto ao longo do qual os caracteres de um texto são renderizados ou um caminho de movimento ao longo do qual um elemento referenciado é animado.

func (*TagSvgGlobal) PathLength 

func (e *TagSvgGlobal) PathLength(value interface{}) (ref *TagSvgGlobal)

PathLength

English:

The pathLength attribute lets authors specify a total length for the path, in user units. This value is then used to calibrate the browser's distance calculations with those of the author, by scaling all distance computations using the ratio pathLength/(computed value of path length).

This can affect the actual rendered lengths of paths; including text paths, animation paths, and various stroke operations. Basically, all computations that require the length of the path. stroke-dasharray, for example, will assume the start of the path being 0 and the end point the value defined in the pathLength attribute.

Português:

O atributo pathLength permite que os autores especifiquem um comprimento total para o caminho, em unidades de usuário. Este valor é então usado para calibrar os cálculos de distância do navegador com os do autor, escalando todos os cálculos de distância usando a razão pathLength (valor calculado do comprimento do caminho).

Isso pode afetar os comprimentos reais dos caminhos renderizados; incluindo caminhos de texto, caminhos de animação e várias operações de traçado. Basicamente, todos os cálculos que exigem o comprimento do caminho. stroke-dasharray, por exemplo, assumirá o início do caminho sendo 0 e o ponto final o valor definido no atributo pathLength.

func (*TagSvgGlobal) PatternContentUnits 

func (e *TagSvgGlobal) PatternContentUnits(value interface{}) (ref *TagSvgGlobal)

PatternContentUnits

English:

The patternContentUnits attribute indicates which coordinate system to use for the contents of the <pattern> element. 

Input:
  value: specifies the coordinate system
    const KSvgUnits... (e.g. KSvgUnitsObjectBoundingBox)
    any other type: interface{}

Notes:
  * That this attribute has no effect if attribute viewBox is specified on the <pattern> element.

Português:

O atributo patternContentUnits indica qual sistema de coordenadas deve ser usado para o conteúdo do elemento <pattern>. 

Entrada:
  value: especifica o sistema de coordenadas
    const KSvgUnits... (e.g. KSvgUnitsObjectBoundingBox)
    qualquer outro tipo: interface{}

Notas:
  * Que este atributo não tem efeito se o atributo viewBox for especificado no elemento <pattern>.

func (*TagSvgGlobal) PatternTransform 

func (e *TagSvgGlobal) PatternTransform(value interface{}) (ref *TagSvgGlobal)

PatternTransform

English:

The patternTransform attribute defines a list of transform definitions that are applied to a pattern tile.

Português:

O atributo patternTransform define uma lista de definições de transformação que são aplicadas a um bloco de padrão.

func (*TagSvgGlobal) PatternUnits 

func (e *TagSvgGlobal) PatternUnits(value interface{}) (ref *TagSvgGlobal)

PatternUnits

English:

The patternUnits attribute indicates which coordinate system to use for the geometry properties of the <pattern> element. 

Input:
  value: specifies the coordinate system
    const KSvgUnits... (e.g. KSvgUnitsObjectBoundingBox)
    any other type: interface{}

Português:

O atributo patternUnits indica qual sistema de coordenadas deve ser usado para as propriedades geométricas do elemento <pattern>. 

Entrada:
  value: especifica o sistema de coordenadas
    const KSvgUnits... (e.g. KSvgUnitsObjectBoundingBox)
    qualquer outro tipo: interface{}

func (*TagSvgGlobal) PointerEvents 

func (e *TagSvgGlobal) PointerEvents(value interface{}) (ref *TagSvgGlobal)

PointerEvents #presentation

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgGlobal) Points 

func (e *TagSvgGlobal) Points(value interface{}) (ref *TagSvgGlobal)

Points

English:

The points attribute defines a list of points. Each point is defined by a pair of number representing a X and a Y coordinate in the user coordinate system. If the attribute contains an odd number of coordinates, the last one will be ignored. 

Input:
  value: list of points representing coordinates X and Y
    [][]float64: [][]float64{{0,0},{1,1},{2,2}} = "0,0 1,1 2,2"
    any other type: interface{}

Português:

O atributo points define uma lista de pontos. Cada ponto é definido por um par de números representando uma coordenada X e Y no sistema de coordenadas do usuário. Se o atributo contiver um número ímpar de coordenadas, a última será ignorada. 

Entrada:
  value: lista de pontos representando as coordenadas X e Y
    [][]float64: [][]float64{{0,0},{1,1},{2,2}} = "0,0 1,1 2,2"
    qualquer outro tipo: interface{}

func (*TagSvgGlobal) PointsAtX 

func (e *TagSvgGlobal) PointsAtX(value interface{}) (ref *TagSvgGlobal)

PointsAtX

English:

The pointsAtX attribute represents the x location in the coordinate system established by attribute primitiveUnits on the <filter> element of the point at which the light source is pointing.

Português:

O atributo pointsAtX representa a localização x no sistema de coordenadas estabelecido pelo atributo primitivaUnits no elemento <filter> do ponto para o qual a fonte de luz está apontando.

func (*TagSvgGlobal) PointsAtY 

func (e *TagSvgGlobal) PointsAtY(value interface{}) (ref *TagSvgGlobal)

PointsAtY

English:

The pointsAtY attribute represents the y location in the coordinate system established by attribute primitiveUnits on the <filter> element of the point at which the light source is pointing.

Português:

O atributo pointsAtY representa a localização y no sistema de coordenadas estabelecido pelo atributo primitivaUnits no elemento <filter> do ponto para o qual a fonte de luz está apontando.

func (*TagSvgGlobal) PointsAtZ 

func (e *TagSvgGlobal) PointsAtZ(value interface{}) (ref *TagSvgGlobal)

PointsAtZ

English:

The pointsAtZ attribute represents the y location in the coordinate system established by attribute primitiveUnits on the <filter> element of the point at which the light source is pointing, assuming that, in the initial local coordinate system, the positive z-axis comes out towards the person viewing the content and assuming that one unit along the z-axis equals one unit in x and y. 

Input:
  value: represents the y location in the coordinate system
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo pointsAtZ representa a localização y no sistema de coordenadas estabelecido pelo atributo primitivaUnits no elemento <filter> do ponto em que a fonte de luz está apontando, assumindo que, no sistema de coordenadas local inicial, o eixo z positivo sai em direção a pessoa visualizando o conteúdo e assumindo que uma unidade ao longo do eixo z é igual a uma unidade em x e y. 

Input:
  value: representa a localização y no sistema de coordenadas
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgGlobal) PreserveAlpha 

func (e *TagSvgGlobal) PreserveAlpha(value bool) (ref *TagSvgGlobal)

PreserveAlpha

English:

The preserveAlpha attribute indicates how a <feConvolveMatrix> element handled alpha transparency. 

Input:
  value: indicates how handled alpha transparency.

Português:

O atributo preserveAlpha indica como um elemento <feConvolveMatrix> trata a transparência alfa. 

Input:
  value: indica como a transparência alfa é tratada.

func (*TagSvgGlobal) PreserveAspectRatio 

func (e *TagSvgGlobal) PreserveAspectRatio(ratio, meet interface{}) (ref *TagSvgGlobal)

PreserveAspectRatio

English: 

The preserveAspectRatio attribute indicates how an element with a viewBox providing a given aspect ratio must fit
into a viewport with a different aspect ratio.

 Input:
   ratio: Indicates how an element with a viewBox providing a given aspect ratio.
     const: KRatio... (e.g. KRatioXMinYMin)
     any other type: interface{}
   meet: The meet or slice reference
     const: KMeetOrSliceReference... (e.g. KMeetOrSliceReferenceSlice)
     any other type: interface{}

Because the aspect ratio of an SVG image is defined by the viewBox attribute, if this attribute isn't set, the preserveAspectRatio attribute has no effect (with one exception, the <image> element, as described below).

Português: 

O atributo preserveAspectRatio indica como um elemento com uma viewBox fornecendo uma determinada proporção deve
caber em uma viewport com uma proporção diferente.

 Input:
   ratio: Indica como um elemento com uma viewBox fornece uma determinada proporção.
     const: KRatio... (ex. KRatioXMinYMin)
     qualquer outro tipo: interface{}
   meet: A referência de encontro ou fatia
     const: KMeetOrSliceReference... (ex. KMeetOrSliceReferenceSlice)
     qualquer outro tipo: interface{}

Como a proporção de uma imagem SVG é definida pelo atributo viewBox, se esse atributo não estiver definido, o atributo preserveAspectRatio não terá efeito (com uma exceção, o elemento <image>, conforme descrito abaixo).

func (*TagSvgGlobal) PrimitiveUnits 

func (e *TagSvgGlobal) PrimitiveUnits(value interface{}) (ref *TagSvgGlobal)

PrimitiveUnits

English:

The primitiveUnits attribute specifies the coordinate system for the various length values within the filter primitives and for the attributes that define the filter primitive subregion. 

Input:
  value: specifies the coordinate system
    const KSvgUnits... (e.g. KSvgUnitsObjectBoundingBox)
    any other type: interface{}

Português:

O atributo primitivaUnits especifica o sistema de coordenadas para os vários valores de comprimento dentro das primitivas de filtro e para os atributos que definem a sub-região da primitiva de filtro. 

Entrada:
  value: especifica o sistema de coordenadas
    const KSvgUnits... (e.g. KSvgUnitsObjectBoundingBox)
    qualquer outro tipo: interface{}

func (*TagSvgGlobal) R 

func (e *TagSvgGlobal) R(value interface{}) (ref *TagSvgGlobal)

R

English:

The r attribute defines the radius of a circle. 

Input:
  value: radius of a circle
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo r define o raio de um círculo. 

Input:
  value: raio de um círculo
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgGlobal) Radius 

func (e *TagSvgGlobal) Radius(value interface{}) (ref *TagSvgGlobal)

Radius

English:

The radius attribute represents the radius (or radii) for the operation on a given <feMorphology> filter primitive.

If two numbers are provided, the first number represents the x-radius and the second one the y-radius. If one number is provided, then that value is used for both x and y. The values are in the coordinate system established by the primitiveUnits attribute on the <filter> element.

A negative or zero value disables the effect of the given filter primitive (i.e., the result is the filter input image).

Português:

O atributo radius representa o raio (ou raios) para a operação em uma determinada primitiva de filtro <feMorphology>.

Se dois números forem fornecidos, o primeiro número representa o raio x e o segundo o raio y. Se um número for fornecido, esse valor será usado para x e y. Os valores estão no sistema de coordenadas estabelecido pelo atributo primitivaUnits no elemento <filter>.

Um valor negativo ou zero desativa o efeito da primitiva de filtro fornecida (ou seja, o resultado é a imagem de entrada do filtro).

func (*TagSvgGlobal) RefX 

func (e *TagSvgGlobal) RefX(value interface{}) (ref *TagSvgGlobal)

RefX

English:

The refX attribute defines the x coordinate of an element's reference point. 

Input:
  value: defines the x coordinate of an element's reference point
    float32: 1.0 = "100%"
    const: KPositionHorizontal... (e.g. KPositionHorizontalLeft)
    any other type: interface{}

Português:

O atributo refX define a coordenada x do ponto de referência de um elemento. 

Entrada:
  value: define a coordenada x do ponto de referência de um elemento
    float32: 1.0 = "100%"
    const: KPositionHorizontal... (ex. KPositionHorizontalLeft)
    qualquer outro tipo: interface{}

func (*TagSvgGlobal) RefY 

func (e *TagSvgGlobal) RefY(value interface{}) (ref *TagSvgGlobal)

RefY

English:

The refX attribute defines the y coordinate of an element's reference point. 

Input:
  value: defines the y coordinate of an element's reference point
    float32: 1.0 = "100%"
    const: KPositionVertical... (e.g. KPositionVerticalTop)
    any other type: interface{}

Português:

O atributo refX define a coordenada y do ponto de referência de um elemento. 

Entrada:
  value: define a coordenada y do ponto de referência de um elemento
    float32: 1.0 = "100%"
    const: KPositionVertical... (ex. KPositionVerticalTop)
    qualquer outro tipo: interface{}

func (*TagSvgGlobal) RepeatCount 

func (e *TagSvgGlobal) RepeatCount(value interface{}) (ref *TagSvgGlobal)

RepeatCount

English:

The repeatCount attribute indicates the number of times an animation will take place. 

Input:
  value: indicates the number of times an animation will take place
    int: number of times
    const: KSvgDurIndefinite
    any other type: interface{}

Português:

O atributo repeatCount indica o número de vezes que uma animação ocorrerá. 

Input:
  value: indica o número de vezes que uma animação ocorrerá
    int: número de vezes
    const: KSvgDurIndefinite
    qualquer outro tipo: interface{}

func (*TagSvgGlobal) RepeatDur 

func (e *TagSvgGlobal) RepeatDur(value interface{}) (ref *TagSvgGlobal)

RepeatDur

English:

The repeatDur attribute specifies the total duration for repeating an animation. 

Input:
  value: specifies the total duration for repeating an animation
    string: "5s"
    time.Duration: 5*time.Second = "5s"
    const: KSvgDurIndefinite
    any other type: interface{}

Português:

O atributo repeatDur especifica a duração total para repetir uma animação. 

Entrada:
  value: especifica a duração total para repetir uma animação
    string: "5s"
    time.Duration: 5*time.Second = "5s"
    const: KSvgDurIndefinite
    qualquer outro tipo: interface{}

func (*TagSvgGlobal) Restart 

func (e *TagSvgGlobal) Restart(value interface{}) (ref *TagSvgGlobal)

Restart

English:

The restart attribute specifies whether or not an animation can restart. 

Input:
  value: especifica se uma animação pode ou não reiniciar
    const: KSvgAnimationRestart... (e.g. KSvgAnimationRestartAlways)
    any other type: interface{}

Português:

O atributo restart especifica se uma animação pode ou não reiniciar. 

Entrada:
  value: especifica se uma animação pode ou não reiniciar
    const: KSvgAnimationRestart... (ex. KSvgAnimationRestartAlways)
    qualquer outro tipo: interface{}

func (*TagSvgGlobal) Result 

func (e *TagSvgGlobal) Result(value interface{}) (ref *TagSvgGlobal)

Result

English:

The result attribute defines the assigned name for this filter primitive. If supplied, then graphics that result from processing this filter primitive can be referenced by an in attribute on a subsequent filter primitive within the same <filter> element. If no value is provided, the output will only be available for re-use as the implicit input into the next filter primitive if that filter primitive provides no value for its in attribute.

Português:

O atributo result define o nome atribuído para esta primitiva de filtro. Se fornecido, os gráficos resultantes do processamento dessa primitiva de filtro podem ser referenciados por um atributo in em uma primitiva de filtro subsequente dentro do mesmo elemento <filter>. Se nenhum valor for fornecido, a saída só estará disponível para reutilização como entrada implícita na próxima primitiva de filtro se essa primitiva de filtro não fornecer valor para seu atributo in.

func (*TagSvgGlobal) Rotate 

func (e *TagSvgGlobal) Rotate(value interface{}) (ref *TagSvgGlobal)

Rotate

English:

The rotate attribute specifies how the animated element rotates as it travels along a path specified in an <animateMotion> element. 

Input:
  value: specifies how the animated element rotates
    const: KSvgRotate... (e.g. KSvgRotateAutoReverse)
    any other type: interface{}

Português:

O atributo de rotação especifica como o elemento animado gira enquanto percorre um caminho especificado em um elemento <animateMotion>. 

Entrada:
  value: especifica como o elemento animado gira
    const: KSvgRotate... (e.g. KSvgRotateAutoReverse)
    qualquer outro tipo: interface{}

func (*TagSvgGlobal) Rx 

func (e *TagSvgGlobal) Rx(value float64) (ref *TagSvgGlobal)

Rx

English:

The rx attribute defines a radius on the x-axis.

Português:

O atributo rx define um raio no eixo x.

func (*TagSvgGlobal) Ry 

func (e *TagSvgGlobal) Ry(value float64) (ref *TagSvgGlobal)

Ry

English:

The ry attribute defines a radius on the y-axis.

Português:

O atributo ry define um raio no eixo y.

func (*TagSvgGlobal) Scale 

func (e *TagSvgGlobal) Scale(value float64) (ref *TagSvgGlobal)

Scale

English:

The scale attribute defines the displacement scale factor to be used on a <feDisplacementMap> filter primitive. The amount is expressed in the coordinate system established by the primitiveUnits attribute on the <filter> element.

Português:

O atributo scale define o fator de escala de deslocamento a ser usado em uma primitiva de filtro <feDisplacementMap>. A quantidade é expressa no sistema de coordenadas estabelecido pelo atributo primitivaUnits no elemento <filter>.

func (*TagSvgGlobal) Seed 

func (e *TagSvgGlobal) Seed(value float64) (ref *TagSvgGlobal)

Seed

English:

The seed attribute represents the starting number for the pseudo random number generator of the <feTurbulence> filter primitive.

Português:

O atributo seed representa o número inicial para o gerador de números pseudo aleatórios da primitiva de filtro <feTurbulence>.

func (*TagSvgGlobal) ShapeRendering 

func (e *TagSvgGlobal) ShapeRendering(value interface{}) (ref *TagSvgGlobal)

ShapeRendering #presentation

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgGlobal) Side 

func (e *TagSvgGlobal) Side(value interface{}) (ref *TagSvgGlobal)

Side

English:

The side attribute determines the side of a path the text is placed on (relative to the path direction). 

Input:
  value: side of a path the text is placed
    const: KSvgSide... (e.g. KSvgSideRight)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo side determina o lado de um caminho em que o texto é colocado (em relação à direção do caminho). 

Entrada:
  value: lado de um caminho em que o texto é colocado
    const: KSvgSide... (e.g. KSvgSideRight)
    qualquer outro tipo: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgGlobal) Spacing 

func (e *TagSvgGlobal) Spacing(value interface{}) (ref *TagSvgGlobal)

Spacing

English:

The spacing attribute indicates how the user agent should determine the spacing between typographic characters that are to be rendered along a path. 

Input:
  value: indicates how the user agent should determine the spacing
    const: KSvgSpacing... (e.g. KSvgSpacingExact)
    any other type: interface{}

Português:

O atributo spacing indica como o agente do usuário deve determinar o espaçamento entre os caracteres tipográficos que devem ser renderizados ao longo de um caminho. 

Entrada:
  value: indica como o agente do usuário deve determinar o espaçamento
    const: KSvgSpacing... (ex. KSvgSpacingExact)
    qualquer outro tipo: interface{}

func (*TagSvgGlobal) SpecularConstant 

func (e *TagSvgGlobal) SpecularConstant(value float64) (ref *TagSvgGlobal)

SpecularConstant

English:

The specularConstant attribute controls the ratio of reflection of the specular lighting. It represents the ks value in the Phong lighting model. The bigger the value the stronger the reflection.

Português:

O atributo specularConstant controla a proporção de reflexão da iluminação especular. Ele representa o valor ks no modelo de iluminação Phong. Quanto maior o valor, mais forte a reflexão.

func (*TagSvgGlobal) SpecularExponent 

func (e *TagSvgGlobal) SpecularExponent(value float64) (ref *TagSvgGlobal)

SpecularExponent

English:

The specularExponent attribute controls the focus for the light source. The bigger the value the brighter the light.

Português:

O atributo specularExponent controla o foco da fonte de luz. Quanto maior o valor, mais brilhante é a luz.

func (*TagSvgGlobal) SpreadMethod 

func (e *TagSvgGlobal) SpreadMethod(value interface{}) (ref *TagSvgGlobal)

SpreadMethod

English:

The spreadMethod attribute determines how a shape is filled beyond the defined edges of a gradient. 

Input:
  value: determines how a shape is filled
    const: KSvgSpreadMethod... (e.g. KSvgSpreadMethodReflect)
    any other type: interface{}

Português:

O atributo spreadMethod determina como uma forma é preenchida além das bordas definidas de um gradiente. 

Entrada:
  value: determina como uma forma é preenchida
    const: KSvgSpreadMethod... (e.g. KSvgSpreadMethodReflect)
    qualquer outro tipo: interface{}

func (*TagSvgGlobal) StartOffset 

func (e *TagSvgGlobal) StartOffset(value interface{}) (ref *TagSvgGlobal)

StartOffset

English:

The startOffset attribute defines an offset from the start of the path for the initial current text position along the path after converting the path to the <textPath> element's coordinate system. 

Input:
  value: defines an offset from the start
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo startOffset define um deslocamento do início do caminho para a posição inicial do texto atual ao longo do caminho após a conversão do caminho para o sistema de coordenadas do elemento <textPath>. 

Entrada:
  value: define um deslocamento desde o início
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgGlobal) StdDeviation 

func (e *TagSvgGlobal) StdDeviation(value interface{}) (ref *TagSvgGlobal)

StdDeviation

English:

The stdDeviation attribute defines the standard deviation for the blur operation. 

Input:
  value: defines the standard deviation
    []float64: []float64{2,5} = "2 5"
    any other type: interface{}

Português:

O atributo stdDeviation define o desvio padrão para a operação de desfoque. 

Input:
  value: define o desvio padrão
    []float64: []float64{2,5} = "2 5"
    qualquer outro tipo: interface{}

func (*TagSvgGlobal) StitchTiles 

func (e *TagSvgGlobal) StitchTiles(value interface{}) (ref *TagSvgGlobal)

StitchTiles

English:

The stitchTiles attribute defines how the Perlin Noise tiles behave at the border. 

Input:
  value: defines how the Perlin Noise tiles behave at the border
    const: KSvgStitchTiles... (e.g. KSvgStitchTilesNoStitch)
    any other type: interface{}

Português:

O atributo stitchTiles define como os blocos Perlin Noise se comportam na borda. 

Entrada:
  value: define como os blocos Perlin Noise se comportam na borda
    const: KSvgStitchTiles... (ex. KSvgStitchTilesNoStitch)
    qualquer outro tipo: interface{}

func (*TagSvgGlobal) StopColor 

func (e *TagSvgGlobal) StopColor(value interface{}) (ref *TagSvgGlobal)

StopColor #presentation

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgGlobal) StopOpacity 

func (e *TagSvgGlobal) StopOpacity(value interface{}) (ref *TagSvgGlobal)

StopOpacity #presentation

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgGlobal) StrikethroughPosition 

func (e *TagSvgGlobal) StrikethroughPosition(value float64) (ref *TagSvgGlobal)

StrikethroughPosition

English:

The strikethrough-position attribute represents the ideal vertical position of the strikethrough. The strikethrough position is expressed in the font's coordinate system.

Português:

O atributo posição tachada representa a posição vertical ideal do tachado. A posição tachada é expressa no sistema de coordenadas da fonte.

func (*TagSvgGlobal) StrikethroughThickness 

func (e *TagSvgGlobal) StrikethroughThickness(value float64) (ref *TagSvgGlobal)

StrikethroughThickness

English:

The strikethrough-thickness attribute represents the ideal thickness of the strikethrough. The strikethrough thickness is expressed in the font's coordinate system.

Português:

O atributo tachado-espessura representa a espessura ideal do tachado. A espessura tachada é expressa no sistema de coordenadas da fonte.

func (*TagSvgGlobal) Stroke 

func (e *TagSvgGlobal) Stroke(value interface{}) (ref *TagSvgGlobal)

Stroke #presentation

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgGlobal) StrokeDashOffset 

func (e *TagSvgGlobal) StrokeDashOffset(value interface{}) (ref *TagSvgGlobal)

StrokeDashOffset

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    float32: 0.1 = "10%"
    []float32: (e.g. []float32{0.04, 0.01, 0.02}) = "4% 1% 2%"
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    float32: 0.1 = "10%"
    []float32: (e.g. []float32{0.04, 0.01, 0.02}) = "4% 1% 2%"
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgGlobal) StrokeDasharray 

func (e *TagSvgGlobal) StrokeDasharray(value interface{}) (ref *TagSvgGlobal)

StrokeDasharray #presentation

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgGlobal) StrokeLineCap 

func (e *TagSvgGlobal) StrokeLineCap(value interface{}) (ref *TagSvgGlobal)

StrokeLineCap #presentation

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgGlobal) StrokeLineJoin 

func (e *TagSvgGlobal) StrokeLineJoin(value interface{}) (ref *TagSvgGlobal)

StrokeLineJoin #presentation

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgGlobal) StrokeMiterLimit 

func (e *TagSvgGlobal) StrokeMiterLimit(value float64) (ref *TagSvgGlobal)

StrokeMiterLimit #presentation

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgGlobal) StrokeOpacity 

func (e *TagSvgGlobal) StrokeOpacity(value interface{}) (ref *TagSvgGlobal)

StrokeOpacity #presentation

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgGlobal) StrokeWidth 

func (e *TagSvgGlobal) StrokeWidth(value interface{}) (ref *TagSvgGlobal)

StrokeWidth #presentation

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgGlobal) Style 

func (e *TagSvgGlobal) Style(value string) (ref *TagSvgGlobal)

Style #styling

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgGlobal) SurfaceScale 

func (e *TagSvgGlobal) SurfaceScale(value float64) (ref *TagSvgGlobal)

SurfaceScale

English:

The surfaceScale attribute represents the height of the surface for a light filter primitive.

Português:

O atributo surfaceScale representa a altura da superfície para uma primitiva de filtro de luz.

func (*TagSvgGlobal) SystemLanguage 

func (e *TagSvgGlobal) SystemLanguage(value interface{}) (ref *TagSvgGlobal)

SystemLanguage #conditionalProcessingAttributes

English:

The systemLanguage attribute represents a list of supported language tags. This list is matched against the language defined in the user preferences.

Português:

O atributo systemLanguage representa uma lista de tags de idioma com suporte. Esta lista é comparada com o idioma definido nas preferências do usuário.

func (*TagSvgGlobal) Tabindex 

func (e *TagSvgGlobal) Tabindex(value int) (ref *TagSvgGlobal)

Tabindex #core

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgGlobal) TableValues 

func (e *TagSvgGlobal) TableValues(value interface{}) (ref *TagSvgGlobal)

TableValues

English:

The tableValues attribute defines a list of numbers defining a lookup table of values for a color component transfer function. 

Input:
  value: defines a list of numbers
    []float64: e.g. []float64{0.0, 1.0} = "0 1"
    any other type: interface{}

Português:

O atributo tableValues define uma lista de números que definem uma tabela de consulta de valores para uma função de transferência de componente de cor. 

Entrada:
  value: define uma lista de números
    []float64: ex. []float64{0.0, 1.0} = "0 1"
    qualquer outro tipo: interface{}

func (*TagSvgGlobal) Target 

func (e *TagSvgGlobal) Target(value interface{}) (ref *TagSvgGlobal)

Target

English:

This attribute specifies the name of the browsing context (e.g., a browser tab or an (X)HTML iframe or object element) into which a document is to be opened when the link is activated 

Input:
  value: specifies the name of the browsing context
    const: KTarget... (e.g. KTargetSelf)
   any other type: interface{}

The target attribute should be used when there are multiple possible targets for the ending resource, such as when the parent document is embedded within an HTML or XHTML document, or is viewed with a tabbed browser.

Português:

Este atributo especifica o nome do contexto de navegação (por exemplo, uma guia do navegador ou um iframe ou elemento de objeto (X)HTML) no qual um documento deve ser aberto quando o link é ativado 

Entrada:
  value: especifica o nome do contexto de navegação
    const: KTarget... (e.g. KTargetSelf)
    qualquer outro tipo: interface{}

O atributo target deve ser usado quando houver vários destinos possíveis para o recurso final, como quando o documento pai estiver incorporado em um documento HTML ou XHTML ou for visualizado em um navegador com guias.

func (*TagSvgGlobal) TargetX 

func (e *TagSvgGlobal) TargetX(value int) (ref *TagSvgGlobal)

TargetX

English:

The targetX attribute determines the positioning in horizontal direction of the convolution matrix relative to a given target pixel in the input image. The leftmost column of the matrix is column number zero. The value must be such that: 0 <= targetX < orderX. 

Input:
  value: determines the positioning in horizontal direction

Português:

O atributo targetX determina o posicionamento na direção horizontal da matriz de convolução em relação a um determinado pixel alvo na imagem de entrada. A coluna mais à esquerda da matriz é a coluna número zero. O valor deve ser tal que: 0 <= targetX < orderX. 

Entrada:
  value: determina o posicionamento na direção horizontal

func (*TagSvgGlobal) TargetY 

func (e *TagSvgGlobal) TargetY(value int) (ref *TagSvgGlobal)

TargetY

English:

The targetY attribute determines the positioning in vertical direction of the convolution matrix relative to a given target pixel in the input image. The topmost row of the matrix is row number zero. The value must be such that: 0 <= targetY < orderY. 

Input:
  value: determines the positioning in vertical direction

Português:

O atributo targetY determina o posicionamento na direção vertical da matriz de convolução em relação a um determinado pixel alvo na imagem de entrada. A linha superior da matriz é a linha número zero. O valor deve ser tal que: 0 <= targetY < orderY. 

Entrada:
  value: determines the positioning in vertical direction

func (*TagSvgGlobal) TextAnchor 

func (e *TagSvgGlobal) TextAnchor(value interface{}) (ref *TagSvgGlobal)

TextAnchor #presentation

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgGlobal) TextDecoration 

func (e *TagSvgGlobal) TextDecoration(value interface{}) (ref *TagSvgGlobal)

TextDecoration #presentation

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgGlobal) TextLength 

func (e *TagSvgGlobal) TextLength(value interface{}) (ref *TagSvgGlobal)

TextLength

English:

The textLength attribute, available on SVG <text> and <tspan> elements, lets you specify the width of the space into which the text will draw. The user agent will ensure that the text does not extend farther than that distance, using the method or methods specified by the lengthAdjust attribute. By default, only the spacing between characters is adjusted, but the glyph size can also be adjusted if you change lengthAdjust. 

Input:
  value: specify the width of the space into which the text will draw
    float32: 1.0 = "100%"
    any other type: interface{}

By using textLength, you can ensure that your SVG text displays at the same width regardless of conditions including web fonts failing to load (or not having loaded yet).

Português:

O atributo textLength, disponível nos elementos SVG <text> e <tspan>, permite especificar a largura do espaço no qual o texto será desenhado. O agente do usuário garantirá que o texto não se estenda além dessa distância, usando o método ou métodos especificados pelo atributo lengthAdjust. Por padrão, apenas o espaçamento entre os caracteres é ajustado, mas o tamanho do glifo também pode ser ajustado se você alterar o lengthAdjust. 

Input:
  value: especifique a largura do espaço no qual o texto será desenhado
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Ao usar textLength, você pode garantir que seu texto SVG seja exibido na mesma largura, independentemente das condições, incluindo fontes da Web que não carregam (ou ainda não foram carregadas).

func (*TagSvgGlobal) TextRendering 

func (e *TagSvgGlobal) TextRendering(value interface{}) (ref *TagSvgGlobal)

TextRendering #presentation

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgGlobal) To 

func (e *TagSvgGlobal) To(value interface{}) (ref *TagSvgGlobal)

To

English:

The to attribute indicates the final value of the attribute that will be modified during the animation. 

Input:
  value: final value of the attribute
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1),rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0%, 10%"
    []float64: []float64{0.0, 10.0} = "0, 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s, 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    any other type: interface{}

The value of the attribute will change between the from attribute value and this value.

Português:

O atributo to indica o valor final do atributo que será modificado durante a animação. 

Entrada:
  value: valor final do atributo
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1),rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0%, 10%"
    []float64: []float64{0.0, 10.0} = "0, 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s, 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    qualquer outro tipo: interface{}

O valor do atributo mudará entre o valor do atributo from e este valor.

func (*TagSvgGlobal) Transform 

func (e *TagSvgGlobal) Transform(value interface{}) (ref *TagSvgGlobal)

Transform #presentation

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgGlobal) TransformOrigin 

func (e *TagSvgGlobal) TransformOrigin(value interface{}) (ref *TagSvgGlobal)

TransformOrigin

English:

The transform-origin SVG attribute sets the origin for an item's transformations. 

Input:
  valueA, valueB: the origin for an item's transformations
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute in SVG, transform-origin corresponds in syntax and behavior to the transform-origin
    property in CSS, and can be used as CSS property to style SVG. See the CSS transform-origin property for more
    information.

Português:

O atributo SVG transform-origin define a origem das transformações de um item. 

Entrada:
  valueA, valueB: a origem das transformações de um item
    const: KSvgTransformOrigin... (ex. KSvgTransformOriginLeft)
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como um atributo de apresentação em SVG, transform-origin corresponde em sintaxe e comportamento à propriedade
    transform-origin em CSS e pode ser usado como propriedade CSS para estilizar SVG. Consulte a propriedade
    transform-origin do CSS para obter mais informações.

func (*TagSvgGlobal) Type 

func (e *TagSvgGlobal) Type(value interface{}) (ref *TagSvgGlobal)

Type

English:

fixme: comentar 

Input:
  value:
    fixme: comentar
    any other type: interface{}

For the <animateTransform> element, it defines the type of transformation, whose values change over time. For the <feColorMatrix> element, it indicates the type of matrix operation. The keyword matrix indicates that a full 5x4 matrix of values will be provided. The other keywords represent convenience shortcuts to allow commonly used color operations to be performed without specifying a complete matrix. For the <feFuncR>, <feFuncG>, <feFuncB>, and <feFuncA> elements, it Indicates the type of component transfer function. For the <feTurbulence> element, it indicates whether the filter primitive should perform a noise or turbulence function. For the <style> and <script> elements, it defines the content type of the element.

Português:

fixme: comentar 

Input:
  value:
    fixme: comentar
    any other type: interface{}

Para o elemento <animateTransform>, define o tipo de transformação, cujos valores mudam ao longo do tempo. Para o elemento <feColorMatrix>, indica o tipo de operação da matriz. A matriz de palavras-chave indica que uma matriz de valores 5x4 completa será fornecida. As outras palavras-chave representam atalhos de conveniência para permitir que as operações de cores comumente usadas sejam executadas sem especificar uma matriz completa. Para os elementos <feFuncR>, <feFuncG>, <feFuncB> e <feFuncA>, indica o tipo de função de transferência do componente. Para o elemento <feTurbulence>, indica se a primitiva do filtro deve executar uma função de ruído ou turbulência. Para os elementos <style> e <script>, define o tipo de conteúdo do elemento.

func (*TagSvgGlobal) UnderlinePosition 

func (e *TagSvgGlobal) UnderlinePosition(value interface{}) (ref *TagSvgGlobal)

UnderlinePosition

English:

The underline-position attribute represents the ideal vertical position of the underline. The underline position is expressed in the font's coordinate system.

Português:

O atributo underline-position representa a posição vertical ideal do sublinhado. A posição do sublinhado é expressa no sistema de coordenadas da fonte.

func (*TagSvgGlobal) UnderlineThickness 

func (e *TagSvgGlobal) UnderlineThickness(value interface{}) (ref *TagSvgGlobal)

UnderlineThickness

English:

The underline-thickness attribute represents the ideal thickness of the underline. The underline thickness is expressed in the font's coordinate system.

Português:

O atributo underline-thickness representa a espessura ideal do sublinhado. A espessura do sublinhado é expressa no sistema de coordenadas da fonte.

func (*TagSvgGlobal) UnicodeBidi 

func (e *TagSvgGlobal) UnicodeBidi(value interface{}) (ref *TagSvgGlobal)

UnicodeBidi #presentation

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgGlobal) Values 

func (e *TagSvgGlobal) Values(value interface{}) (ref *TagSvgGlobal)

Values

English:

The values attribute has different meanings, depending upon the context where it's used, either it defines a sequence of values used over the course of an animation, or it's a list of numbers for a color matrix, which is interpreted differently depending on the type of color change to be performed. 

Input:
  value: list of values
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1),rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0%, 10%"
    []float64: []float64{0.0, 10.0} = "0, 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s, 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    any other type: interface{}

Português:

O atributo values tem significados diferentes, dependendo do contexto em que é usado, ou define uma sequência de valores usados ao longo de uma animação, ou é uma lista de números para uma matriz de cores, que é interpretada de forma diferente dependendo do tipo de mudança de cor a ser executada. 

Input:
  value: lista de valores
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1),rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0%, 10%"
    []float64: []float64{0.0, 10.0} = "0, 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s, 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    any other type: interface{}

func (*TagSvgGlobal) VectorEffect 

func (e *TagSvgGlobal) VectorEffect(value interface{}) (ref *TagSvgGlobal)

VectorEffect #presentation

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgGlobal) ViewBox 

func (e *TagSvgGlobal) ViewBox(value interface{}) (ref *TagSvgGlobal)

ViewBox

English:

The viewBox attribute defines the position and dimension, in user space, of an SVG viewport. 

Input:
  value: defines the position and dimension, in user space, of an SVG viewport
    []float64: ex. []float64{0.0, 0.0, 10.0, 10.0} = "0 0 10 10"
    any other type: interface{}

The value of the viewBox attribute is a list of four numbers: min-x, min-y, width and height. The numbers, which are separated by whitespace and/or a comma, specify a rectangle in user space which is mapped to the bounds of the viewport established for the associated SVG element (not the browser viewport).

Português:

O atributo viewBox define a posição e a dimensão, no espaço do usuário, de uma viewport SVG. 

Input:
  value: define a posição e dimensão, no espaço do usuário, de uma viewport SVG
    []float64: ex. []float64{0.0, 0.0, 10.0, 10.0} = "0 0 10 10"
    qualquer outro tipo: interface{}

O valor do atributo viewBox é uma lista de quatro números: min-x, min-y, largura e altura. Os números, que são separados por espaço em branco e ou vírgula, especificam um retângulo no espaço do usuário que é mapeado para os limites da janela de visualização estabelecida para o elemento SVG associado (não a janela de visualização do navegador).

func (*TagSvgGlobal) Visibility 

func (e *TagSvgGlobal) Visibility(value interface{}) (ref *TagSvgGlobal)

Visibility #presentation

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgGlobal) Width 

func (e *TagSvgGlobal) Width(value interface{}) (ref *TagSvgGlobal)

Width

English:

The width attribute defines the horizontal length of an element in the user coordinate system. 

Input:
  value: the horizontal length of an element
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo largura define o comprimento horizontal de um elemento no sistema de coordenadas do usuário. 

Entrada:
  value: o comprimento horizontal de um elemento
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgGlobal) WordSpacing 

func (e *TagSvgGlobal) WordSpacing(value interface{}) (ref *TagSvgGlobal)

WordSpacing #presentation

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgGlobal) WritingMode 

func (e *TagSvgGlobal) WritingMode(value interface{}) (ref *TagSvgGlobal)

WritingMode #presentation

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgGlobal) X 

func (e *TagSvgGlobal) X(value interface{}) (ref *TagSvgGlobal)

X

English:

The x attribute defines an x-axis coordinate in the user coordinate system. 

Input:
  value: defines an x-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo x define uma coordenada do eixo x no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo x
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgGlobal) X1 

func (e *TagSvgGlobal) X1(value interface{}) (ref *TagSvgGlobal)

X1

English:

The x1 attribute is used to specify the first x-coordinate for drawing an SVG element that requires more than one coordinate. 

Input:
  value: specify the first x-coordinate
    float32: 1.0 = "100%"
    any other type: interface{}

Elements that only need one coordinate use the x attribute instead.

Português:

O atributo x1 é usado para especificar a primeira coordenada x para desenhar um elemento SVG que requer mais de uma coordenada. 

Input:
  value: especifique a primeira coordenada x
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Elementos que precisam apenas de uma coordenada usam o atributo x.

func (*TagSvgGlobal) X2 

func (e *TagSvgGlobal) X2(value interface{}) (ref *TagSvgGlobal)

X2

English:

The x2 attribute is used to specify the second x-coordinate for drawing an SVG element that requires more than one coordinate. Elements that only need one coordinate use the x attribute instead. 

Input:
  value: specify the second x-coordinate
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo x2 é usado para especificar a segunda coordenada x para desenhar um elemento SVG que requer mais de uma coordenada. Elementos que precisam apenas de uma coordenada usam o atributo x. 

Entrada:
  value: especifique a segunda coordenada x
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgGlobal) XChannelSelector 

func (e *TagSvgGlobal) XChannelSelector(value interface{}) (ref *TagSvgGlobal)

XChannelSelector

English:

The xChannelSelector attribute indicates which color channel from in2 to use to displace the pixels in in along the x-axis. 

Input:
  value: indicates which color channel from in2
    const: KSvgChannelSelector... (e.g. KSvgChannelSelectorR)
    any other type: interface{}

Português:

O atributo xChannelSelector indica qual canal de cor de in2 usar para deslocar os pixels ao longo do eixo x. 

Entrada:
  value: indica qual canal de cor da in2
    const: KSvgChannelSelector... (ex. KSvgChannelSelectorR)
    qualquer outro tipo: interface{}

func (*TagSvgGlobal) XmlLang 

func (e *TagSvgGlobal) XmlLang(value interface{}) (ref *TagSvgGlobal)

XmlLang #core

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

func (*TagSvgGlobal) Y 

func (e *TagSvgGlobal) Y(value interface{}) (ref *TagSvgGlobal)

Y

English:

The y attribute defines an y-axis coordinate in the user coordinate system. 

Input:
  value: defines an y-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo y define uma coordenada do eixo y no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo y
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgGlobal) Y1 

func (e *TagSvgGlobal) Y1(value interface{}) (ref *TagSvgGlobal)

Y1

English:

The y1 attribute is used to specify the first y-coordinate for drawing an SVG element that requires more than one coordinate. 

Input:
  value: specify the first y-coordinate
    float32: 1.0 = "100%"
    any other type: interface{}

Elements that only need one coordinate use the y attribute instead.

Português:

O atributo y1 é usado para especificar a primeira coordenada y para desenhar um elemento SVG que requer mais de uma coordenada. 

Input:
  value: especifique a primeira coordenada y
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Elementos que precisam apenas de uma coordenada usam o atributo y.

func (*TagSvgGlobal) Y2 

func (e *TagSvgGlobal) Y2(value interface{}) (ref *TagSvgGlobal)

Y2

English:

The y2 attribute is used to specify the second y-coordinate for drawing an SVG element that requires more than one coordinate. 

Input:
  value: specify the second x-coordinate
    float32: 1.0 = "100%"
    any other type: interface{}

Elements that only need one coordinate use the x attribute instead.

Português:

O atributo y2 é usado para especificar a segunda coordenada y para desenhar um elemento SVG que requer mais de uma coordenada. 

Entrada:
  value: especifique a segunda coordenada x
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Elementos que precisam apenas de uma coordenada usam o atributo y.

func (*TagSvgGlobal) YChannelSelector 

func (e *TagSvgGlobal) YChannelSelector(value interface{}) (ref *TagSvgGlobal)

YChannelSelector

English:

The yChannelSelector attribute indicates which color channel from in2 to use to displace the pixels in along the y-axis. 

Input:
  value: indicates which color channel from in2
    const: KSvgChannelSelector... (e.g. KSvgChannelSelectorR)
    any other type: interface{}

Português:

O atributo yChannelSelector indica qual canal de cor de in2 usar para deslocar os pixels ao longo do eixo y. 

Entrada:
  value: indica qual canal de cor da in2
    const: KSvgChannelSelector... (ex. KSvgChannelSelectorR)
    qualquer outro tipo: interface{}

func (*TagSvgGlobal) Z 

func (e *TagSvgGlobal) Z(value interface{}) (ref *TagSvgGlobal)

Z

English:

The z attribute defines the location along the z-axis for a light source in the coordinate system established by the primitiveUnits attribute on the <filter> element, assuming that, in the initial coordinate system, the positive z-axis comes out towards the person viewing the content and assuming that one unit along the z-axis equals one unit in x and y.

Português:

O atributo z define a localização ao longo do eixo z para uma fonte de luz no sistema de coordenadas estabelecido pelo atributo primitivoUnits no elemento <filter>, assumindo que, no sistema de coordenadas inicial, o eixo z positivo sai em direção à pessoa visualizar o conteúdo e assumir que uma unidade ao longo do eixo z é igual a uma unidade em x e y.

type TagSvgImage 

type TagSvgImage struct {
	// contains filtered or unexported fields
}

TagSvgImage

English:

The <image> SVG element includes images inside SVG documents. It can display raster image files or other SVG files.

The only image formats SVG software must support are JPEG, PNG, and other SVG files. Animated GIF behavior is undefined.

SVG files displayed with <image> are treated as an image: external resources aren't loaded, :visited styles aren't applied, and they cannot be interactive. To include dynamic SVG elements, try <use> with an external URL. To include SVG files and run scripts inside them, try <object> inside of <foreignObject>. 

Notes:
  * The HTML spec defines <image> as a synonym for <img> while parsing HTML. This specific element and its
    behavior only apply inside SVG documents or inline SVG.

Português:

O elemento SVG <image> inclui imagens dentro de documentos SVG. Ele pode exibir arquivos de imagem raster ou outros arquivos SVG.

Os únicos formatos de imagem que o software SVG deve suportar são JPEG, PNG e outros arquivos SVG. O comportamento do GIF animado é indefinido.

Arquivos SVG exibidos com <image> são tratados como uma imagem: recursos externos não são carregados, estilos :visited não são aplicados e não podem ser interativos. Para incluir elementos SVG dinâmicos, tente <use> com uma URL externa. Para incluir arquivos SVG e executar scripts dentro deles, tente <object> dentro de <foreignObject>. 

Notes:
  * The HTML spec defines <image> as a synonym for <img> while parsing HTML. This specific element and its
    behavior only apply inside SVG documents or inline SVG.

func (*TagSvgImage) Append 

func (e *TagSvgImage) Append(elements ...Compatible) (ref *TagSvgImage)

func (*TagSvgImage) AppendById 

func (e *TagSvgImage) AppendById(appendId string) (ref *TagSvgImage)

func (*TagSvgImage) AppendToElement 

func (e *TagSvgImage) AppendToElement(el js.Value) (ref *TagSvgImage)

func (*TagSvgImage) AppendToStage 

func (e *TagSvgImage) AppendToStage() (ref *TagSvgImage)

func (*TagSvgImage) BaselineShift 

func (e *TagSvgImage) BaselineShift(baselineShift interface{}) (ref *TagSvgImage)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgImage) Class 

func (e *TagSvgImage) Class(class string) (ref *TagSvgImage)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgImage) ClipPath 

func (e *TagSvgImage) ClipPath(clipPath string) (ref *TagSvgImage)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgImage) ClipRule 

func (e *TagSvgImage) ClipRule(value interface{}) (ref *TagSvgImage)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgImage) Color 

func (e *TagSvgImage) Color(value interface{}) (ref *TagSvgImage)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgImage) ColorInterpolation 

func (e *TagSvgImage) ColorInterpolation(value interface{}) (ref *TagSvgImage)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgImage) ColorInterpolationFilters 

func (e *TagSvgImage) ColorInterpolationFilters(value interface{}) (ref *TagSvgImage)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgImage) CreateElement 

func (e *TagSvgImage) CreateElement() (ref *TagSvgImage)

func (*TagSvgImage) CrossOrigin 

func (e *TagSvgImage) CrossOrigin(crossOrigin SvgCrossOrigin) (ref *TagSvgImage)

CrossOrigin

English: 

The crossorigin attribute, valid on the <image> element, provides support for CORS, defining how the element handles
crossorigin requests, thereby enabling the configuration of the CORS requests for the element's fetched data. It is
a CORS settings attribute.

Português: 

The crossorigin attribute, valid on the <image> element, provides support for CORS, defining how the element handles
crossorigin requests, thereby enabling the configuration of the CORS requests for the element's fetched data. It is
a CORS settings attribute.

func (*TagSvgImage) Cursor 

func (e *TagSvgImage) Cursor(cursor SvgCursor) (ref *TagSvgImage)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgImage) Direction 

func (e *TagSvgImage) Direction(direction SvgDirection) (ref *TagSvgImage)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgImage) Display 

func (e *TagSvgImage) Display(value interface{}) (ref *TagSvgImage)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgImage) DominantBaseline 

func (e *TagSvgImage) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgImage)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgImage) Fill 

func (e *TagSvgImage) Fill(value interface{}) (ref *TagSvgImage)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgImage) FillOpacity 

func (e *TagSvgImage) FillOpacity(value interface{}) (ref *TagSvgImage)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgImage) FillRule 

func (e *TagSvgImage) FillRule(fillRule SvgFillRule) (ref *TagSvgImage)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgImage) Filter 

func (e *TagSvgImage) Filter(filter string) (ref *TagSvgImage)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgImage) FloodColor 

func (e *TagSvgImage) FloodColor(floodColor interface{}) (ref *TagSvgImage)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgImage) FloodOpacity 

func (e *TagSvgImage) FloodOpacity(floodOpacity float64) (ref *TagSvgImage)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgImage) FontFamily 

func (e *TagSvgImage) FontFamily(fontFamily string) (ref *TagSvgImage)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgImage) FontSize 

func (e *TagSvgImage) FontSize(fontSize interface{}) (ref *TagSvgImage)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgImage) FontSizeAdjust 

func (e *TagSvgImage) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgImage)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgImage) FontStretch 

func (e *TagSvgImage) FontStretch(fontStretch interface{}) (ref *TagSvgImage)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgImage) FontStyle 

func (e *TagSvgImage) FontStyle(fontStyle FontStyleRule) (ref *TagSvgImage)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgImage) FontVariant 

func (e *TagSvgImage) FontVariant(value interface{}) (ref *TagSvgImage)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgImage) FontWeight 

func (e *TagSvgImage) FontWeight(value interface{}) (ref *TagSvgImage)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgImage) Get 

func (e *TagSvgImage) Get() (el js.Value)

func (*TagSvgImage) HRef 

func (e *TagSvgImage) HRef(href string) (ref *TagSvgImage)

HRef

English: 

The href attribute defines a link to a resource as a reference URL. The exact meaning of that link depends on the
context of each element using it.

 Notes:
   * Specifications before SVG 2 defined an xlink:href attribute, which is now rendered obsolete by the href
     attribute.
     If you need to support earlier browser versions, the deprecated xlink:href attribute can be used as a fallback
     in addition to the href attribute, e.g. <use href="some-id" xlink:href="some-id x="5" y="5" />.

Português: 

O atributo href define um link para um recurso como um URL de referência. O significado exato desse link depende do
contexto de cada elemento que o utiliza.

 Notas:
   * As especificações anteriores ao SVG 2 definiam um atributo xlink:href, que agora se torna obsoleto pelo
     atributo href.
     Se você precisar oferecer suporte a versões anteriores do navegador, o atributo obsoleto xlink:href pode ser
     usado como um substituto além do atributo href, por exemplo,
     <use href="some-id" xlink:href="some-id x="5" y="5" />.

func (*TagSvgImage) Height 

func (e *TagSvgImage) Height(height interface{}) (ref *TagSvgImage)

Height

English: 

The height attribute defines the vertical length of an element in the user coordinate system.
     float32: 1.0 = "100%"
     any other type: interface{}

Português: 

O atributo height define o comprimento vertical de um elemento no sistema de coordenadas do usuário.
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

func (*TagSvgImage) Html 

func (e *TagSvgImage) Html(value string) (ref *TagSvgImage)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgImage) Id 

func (e *TagSvgImage) Id(id string) (ref *TagSvgImage)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgImage) ImageRendering 

func (e *TagSvgImage) ImageRendering(imageRendering string) (ref *TagSvgImage)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgImage) Init 

func (e *TagSvgImage) Init() (ref *TagSvgImage)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgImage) Lang 

func (e *TagSvgImage) Lang(value interface{}) (ref *TagSvgImage)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgImage) LetterSpacing 

func (e *TagSvgImage) LetterSpacing(value float64) (ref *TagSvgImage)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgImage) LightingColor 

func (e *TagSvgImage) LightingColor(value interface{}) (ref *TagSvgImage)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgImage) MarkerEnd 

func (e *TagSvgImage) MarkerEnd(value interface{}) (ref *TagSvgImage)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgImage) MarkerMid 

func (e *TagSvgImage) MarkerMid(value interface{}) (ref *TagSvgImage)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgImage) MarkerStart 

func (e *TagSvgImage) MarkerStart(value interface{}) (ref *TagSvgImage)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgImage) Mask 

func (e *TagSvgImage) Mask(value interface{}) (ref *TagSvgImage)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgImage) Opacity 

func (e *TagSvgImage) Opacity(value interface{}) (ref *TagSvgImage)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgImage) Overflow 

func (e *TagSvgImage) Overflow(value interface{}) (ref *TagSvgImage)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgImage) PointerEvents 

func (e *TagSvgImage) PointerEvents(value interface{}) (ref *TagSvgImage)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgImage) PreserveAspectRatio 

func (e *TagSvgImage) PreserveAspectRatio(ratio, meet interface{}) (ref *TagSvgImage)

PreserveAspectRatio

English: 

The preserveAspectRatio attribute indicates how an element with a viewBox providing a given aspect ratio must fit
into a viewport with a different aspect ratio.

 Input:
   ratio: Indicates how an element with a viewBox providing a given aspect ratio.
     const: KRatio... (e.g. KRatioXMinYMin)
     any other type: interface{}
   meet: The meet or slice reference
     const: KMeetOrSliceReference... (e.g. KMeetOrSliceReferenceSlice)
     any other type: interface{}

Because the aspect ratio of an SVG image is defined by the viewBox attribute, if this attribute isn't set, the preserveAspectRatio attribute has no effect (with one exception, the <image> element, as described below).

Português: 

O atributo preserveAspectRatio indica como um elemento com uma viewBox fornecendo uma determinada proporção deve
caber em uma viewport com uma proporção diferente.

 Input:
   ratio: Indica como um elemento com uma viewBox fornece uma determinada proporção.
     const: KRatio... (ex. KRatioXMinYMin)
     qualquer outro tipo: interface{}
   meet: A referência de encontro ou fatia
     const: KMeetOrSliceReference... (ex. KMeetOrSliceReferenceSlice)
     qualquer outro tipo: interface{}

Como a proporção de uma imagem SVG é definida pelo atributo viewBox, se esse atributo não estiver definido, o atributo preserveAspectRatio não terá efeito (com uma exceção, o elemento <image>, conforme descrito abaixo).

func (*TagSvgImage) ShapeRendering 

func (e *TagSvgImage) ShapeRendering(value interface{}) (ref *TagSvgImage)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgImage) StopColor 

func (e *TagSvgImage) StopColor(value interface{}) (ref *TagSvgImage)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgImage) StopOpacity 

func (e *TagSvgImage) StopOpacity(value interface{}) (ref *TagSvgImage)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgImage) Stroke 

func (e *TagSvgImage) Stroke(value interface{}) (ref *TagSvgImage)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgImage) StrokeDasharray 

func (e *TagSvgImage) StrokeDasharray(value interface{}) (ref *TagSvgImage)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgImage) StrokeLineCap 

func (e *TagSvgImage) StrokeLineCap(value interface{}) (ref *TagSvgImage)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgImage) StrokeLineJoin 

func (e *TagSvgImage) StrokeLineJoin(value interface{}) (ref *TagSvgImage)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgImage) StrokeMiterLimit 

func (e *TagSvgImage) StrokeMiterLimit(value float64) (ref *TagSvgImage)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgImage) StrokeOpacity 

func (e *TagSvgImage) StrokeOpacity(value interface{}) (ref *TagSvgImage)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgImage) StrokeWidth 

func (e *TagSvgImage) StrokeWidth(value interface{}) (ref *TagSvgImage)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgImage) Style 

func (e *TagSvgImage) Style(value string) (ref *TagSvgImage)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgImage) Tabindex 

func (e *TagSvgImage) Tabindex(value int) (ref *TagSvgImage)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgImage) Text 

func (e *TagSvgImage) Text(value string) (ref *TagSvgImage)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgImage) TextAnchor 

func (e *TagSvgImage) TextAnchor(value interface{}) (ref *TagSvgImage)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgImage) TextDecoration 

func (e *TagSvgImage) TextDecoration(value interface{}) (ref *TagSvgImage)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgImage) TextRendering 

func (e *TagSvgImage) TextRendering(value interface{}) (ref *TagSvgImage)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgImage) Transform 

func (e *TagSvgImage) Transform(value interface{}) (ref *TagSvgImage)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgImage) UnicodeBidi 

func (e *TagSvgImage) UnicodeBidi(value interface{}) (ref *TagSvgImage)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgImage) VectorEffect 

func (e *TagSvgImage) VectorEffect(value interface{}) (ref *TagSvgImage)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgImage) Visibility 

func (e *TagSvgImage) Visibility(value interface{}) (ref *TagSvgImage)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgImage) Width 

func (e *TagSvgImage) Width(value interface{}) (ref *TagSvgImage)

Width

English:

The width attribute defines the horizontal length of an element in the user coordinate system. 

Input:
  value: the horizontal length of an element
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo largura define o comprimento horizontal de um elemento no sistema de coordenadas do usuário. 

Entrada:
  value: o comprimento horizontal de um elemento
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgImage) WordSpacing 

func (e *TagSvgImage) WordSpacing(value interface{}) (ref *TagSvgImage)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgImage) WritingMode 

func (e *TagSvgImage) WritingMode(value interface{}) (ref *TagSvgImage)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgImage) X 

func (e *TagSvgImage) X(value interface{}) (ref *TagSvgImage)

X

English:

The x attribute defines an x-axis coordinate in the user coordinate system. 

Input:
  value: defines an x-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo x define uma coordenada do eixo x no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo x
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgImage) XLinkHRef deprecated 

func (e *TagSvgImage) XLinkHRef(value interface{}) (ref *TagSvgImage)

XLinkHRef

English:

Deprecated: use HRef() function

The xlink:href attribute defines a reference to a resource as a reference IRI. The exact meaning of that link depends on the context of each element using it. 

Notes:
  * SVG 2 removed the need for the xlink namespace, so instead of xlink:href you should use href. If you need to
    support earlier browser versions, the deprecated xlink:href attribute can be used as a fallback in addition to
    the href attribute, e.g. <use href="some-id" xlink:href="some-id" x="5" y="5" />.

Português:

Obsoleto: use a função HRef()

O atributo xlink:href define uma referência a um recurso como um IRI de referência. O significado exato desse link depende do contexto de cada elemento que o utiliza. 

Notas:
  * O SVG 2 removeu a necessidade do namespace xlink, então ao invés de xlink:href você deve usar href. Se você
    precisar oferecer suporte a versões anteriores do navegador, o atributo obsoleto xlink:href pode ser usado como
    um substituto além do atributo href, por exemplo, <use href="some-id" xlink:href="some-id" x="5" y="5" >.

func (*TagSvgImage) XmlLang 

func (e *TagSvgImage) XmlLang(value interface{}) (ref *TagSvgImage)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

func (*TagSvgImage) Y 

func (e *TagSvgImage) Y(value interface{}) (ref *TagSvgImage)

Y

English:

The y attribute defines an y-axis coordinate in the user coordinate system. 

Input:
  value: defines an y-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo y define uma coordenada do eixo y no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo y
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

type TagSvgLine 

type TagSvgLine struct {
	// contains filtered or unexported fields
}

TagSvgLine

English:

The <line> element is an SVG basic shape used to create a line connecting two points.

Português:

O elemento <line> é uma forma básica SVG usada para criar uma linha conectando dois pontos.

func (*TagSvgLine) Append 

func (e *TagSvgLine) Append(elements ...Compatible) (ref *TagSvgLine)

func (*TagSvgLine) AppendById 

func (e *TagSvgLine) AppendById(appendId string) (ref *TagSvgLine)

func (*TagSvgLine) AppendToElement 

func (e *TagSvgLine) AppendToElement(el js.Value) (ref *TagSvgLine)

func (*TagSvgLine) AppendToStage 

func (e *TagSvgLine) AppendToStage() (ref *TagSvgLine)

func (*TagSvgLine) BaselineShift 

func (e *TagSvgLine) BaselineShift(baselineShift interface{}) (ref *TagSvgLine)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgLine) Class 

func (e *TagSvgLine) Class(class string) (ref *TagSvgLine)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgLine) ClipPath 

func (e *TagSvgLine) ClipPath(clipPath string) (ref *TagSvgLine)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgLine) ClipRule 

func (e *TagSvgLine) ClipRule(value interface{}) (ref *TagSvgLine)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgLine) Color 

func (e *TagSvgLine) Color(value interface{}) (ref *TagSvgLine)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgLine) ColorInterpolation 

func (e *TagSvgLine) ColorInterpolation(value interface{}) (ref *TagSvgLine)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgLine) ColorInterpolationFilters 

func (e *TagSvgLine) ColorInterpolationFilters(value interface{}) (ref *TagSvgLine)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgLine) CreateElement 

func (e *TagSvgLine) CreateElement() (ref *TagSvgLine)

func (*TagSvgLine) Cursor 

func (e *TagSvgLine) Cursor(cursor SvgCursor) (ref *TagSvgLine)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgLine) Direction 

func (e *TagSvgLine) Direction(direction SvgDirection) (ref *TagSvgLine)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgLine) Display 

func (e *TagSvgLine) Display(value interface{}) (ref *TagSvgLine)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgLine) DominantBaseline 

func (e *TagSvgLine) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgLine)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgLine) Fill 

func (e *TagSvgLine) Fill(value interface{}) (ref *TagSvgLine)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgLine) FillOpacity 

func (e *TagSvgLine) FillOpacity(value interface{}) (ref *TagSvgLine)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgLine) FillRule 

func (e *TagSvgLine) FillRule(fillRule SvgFillRule) (ref *TagSvgLine)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgLine) Filter 

func (e *TagSvgLine) Filter(filter string) (ref *TagSvgLine)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgLine) FloodColor 

func (e *TagSvgLine) FloodColor(floodColor interface{}) (ref *TagSvgLine)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgLine) FloodOpacity 

func (e *TagSvgLine) FloodOpacity(floodOpacity float64) (ref *TagSvgLine)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgLine) FontFamily 

func (e *TagSvgLine) FontFamily(fontFamily string) (ref *TagSvgLine)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgLine) FontSize 

func (e *TagSvgLine) FontSize(fontSize interface{}) (ref *TagSvgLine)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgLine) FontSizeAdjust 

func (e *TagSvgLine) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgLine)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgLine) FontStretch 

func (e *TagSvgLine) FontStretch(fontStretch interface{}) (ref *TagSvgLine)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgLine) FontStyle 

func (e *TagSvgLine) FontStyle(fontStyle FontStyleRule) (ref *TagSvgLine)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgLine) FontVariant 

func (e *TagSvgLine) FontVariant(value interface{}) (ref *TagSvgLine)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgLine) FontWeight 

func (e *TagSvgLine) FontWeight(value interface{}) (ref *TagSvgLine)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgLine) Get 

func (e *TagSvgLine) Get() (el js.Value)

func (*TagSvgLine) Html 

func (e *TagSvgLine) Html(value string) (ref *TagSvgLine)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgLine) Id 

func (e *TagSvgLine) Id(id string) (ref *TagSvgLine)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgLine) ImageRendering 

func (e *TagSvgLine) ImageRendering(imageRendering string) (ref *TagSvgLine)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgLine) Init 

func (e *TagSvgLine) Init() (ref *TagSvgLine)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgLine) Lang 

func (e *TagSvgLine) Lang(value interface{}) (ref *TagSvgLine)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgLine) LetterSpacing 

func (e *TagSvgLine) LetterSpacing(value float64) (ref *TagSvgLine)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgLine) LightingColor 

func (e *TagSvgLine) LightingColor(value interface{}) (ref *TagSvgLine)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgLine) MarkerEnd 

func (e *TagSvgLine) MarkerEnd(value interface{}) (ref *TagSvgLine)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgLine) MarkerMid 

func (e *TagSvgLine) MarkerMid(value interface{}) (ref *TagSvgLine)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgLine) MarkerStart 

func (e *TagSvgLine) MarkerStart(value interface{}) (ref *TagSvgLine)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgLine) Mask 

func (e *TagSvgLine) Mask(value interface{}) (ref *TagSvgLine)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgLine) Opacity 

func (e *TagSvgLine) Opacity(value interface{}) (ref *TagSvgLine)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgLine) Overflow 

func (e *TagSvgLine) Overflow(value interface{}) (ref *TagSvgLine)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgLine) PaintOrder 

func (e *TagSvgLine) PaintOrder(value interface{}) (ref *TagSvgLine)

PaintOrder

English:

The paint-order attribute specifies the order that the fill, stroke, and markers of a given shape or text element are painted. 

Input:
  value: specifies the order that the fill, stroke, and markers
    const: SvgPaintOrder... (e.g. KSvgPaintOrderStroke)
    any other type: interface{}

Notes:
  * As a presentation attribute, paint-order can be used as a CSS property.

Português:

O atributo paint-order especifica a ordem em que o preenchimento, o traçado e os marcadores de uma determinada forma ou elemento de texto são pintados. 

Entrada:
  value: especifica a ordem em que o preenchimento, o traçado e os marcadores
    const: SvgPaintOrder... (e.g. KSvgPaintOrderStroke)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, paint-order pode ser usado como uma propriedade CSS.

func (*TagSvgLine) PathLength 

func (e *TagSvgLine) PathLength(value interface{}) (ref *TagSvgLine)

PathLength

English:

The pathLength attribute lets authors specify a total length for the path, in user units. This value is then used to calibrate the browser's distance calculations with those of the author, by scaling all distance computations using the ratio pathLength/(computed value of path length).

This can affect the actual rendered lengths of paths; including text paths, animation paths, and various stroke operations. Basically, all computations that require the length of the path. stroke-dasharray, for example, will assume the start of the path being 0 and the end point the value defined in the pathLength attribute.

Português:

O atributo pathLength permite que os autores especifiquem um comprimento total para o caminho, em unidades de usuário. Este valor é então usado para calibrar os cálculos de distância do navegador com os do autor, escalando todos os cálculos de distância usando a razão pathLength (valor calculado do comprimento do caminho).

Isso pode afetar os comprimentos reais dos caminhos renderizados; incluindo caminhos de texto, caminhos de animação e várias operações de traçado. Basicamente, todos os cálculos que exigem o comprimento do caminho. stroke-dasharray, por exemplo, assumirá o início do caminho sendo 0 e o ponto final o valor definido no atributo pathLength.

func (*TagSvgLine) PointerEvents 

func (e *TagSvgLine) PointerEvents(value interface{}) (ref *TagSvgLine)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgLine) ShapeRendering 

func (e *TagSvgLine) ShapeRendering(value interface{}) (ref *TagSvgLine)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgLine) StopColor 

func (e *TagSvgLine) StopColor(value interface{}) (ref *TagSvgLine)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgLine) StopOpacity 

func (e *TagSvgLine) StopOpacity(value interface{}) (ref *TagSvgLine)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgLine) Stroke 

func (e *TagSvgLine) Stroke(value interface{}) (ref *TagSvgLine)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgLine) StrokeDashOffset 

func (e *TagSvgLine) StrokeDashOffset(value interface{}) (ref *TagSvgLine)

StrokeDashOffset

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    float32: 0.1 = "10%"
    []float32: (e.g. []float32{0.04, 0.01, 0.02}) = "4% 1% 2%"
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    float32: 0.1 = "10%"
    []float32: (e.g. []float32{0.04, 0.01, 0.02}) = "4% 1% 2%"
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgLine) StrokeDasharray 

func (e *TagSvgLine) StrokeDasharray(value interface{}) (ref *TagSvgLine)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgLine) StrokeLineCap 

func (e *TagSvgLine) StrokeLineCap(value interface{}) (ref *TagSvgLine)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgLine) StrokeLineJoin 

func (e *TagSvgLine) StrokeLineJoin(value interface{}) (ref *TagSvgLine)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgLine) StrokeMiterLimit 

func (e *TagSvgLine) StrokeMiterLimit(value float64) (ref *TagSvgLine)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgLine) StrokeOpacity 

func (e *TagSvgLine) StrokeOpacity(value interface{}) (ref *TagSvgLine)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgLine) StrokeWidth 

func (e *TagSvgLine) StrokeWidth(value interface{}) (ref *TagSvgLine)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgLine) Style 

func (e *TagSvgLine) Style(value string) (ref *TagSvgLine)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgLine) Tabindex 

func (e *TagSvgLine) Tabindex(value int) (ref *TagSvgLine)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgLine) Text 

func (e *TagSvgLine) Text(value string) (ref *TagSvgLine)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgLine) TextAnchor 

func (e *TagSvgLine) TextAnchor(value interface{}) (ref *TagSvgLine)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgLine) TextDecoration 

func (e *TagSvgLine) TextDecoration(value interface{}) (ref *TagSvgLine)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgLine) TextRendering 

func (e *TagSvgLine) TextRendering(value interface{}) (ref *TagSvgLine)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgLine) Transform 

func (e *TagSvgLine) Transform(value interface{}) (ref *TagSvgLine)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgLine) UnicodeBidi 

func (e *TagSvgLine) UnicodeBidi(value interface{}) (ref *TagSvgLine)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgLine) VectorEffect 

func (e *TagSvgLine) VectorEffect(value interface{}) (ref *TagSvgLine)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgLine) Visibility 

func (e *TagSvgLine) Visibility(value interface{}) (ref *TagSvgLine)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgLine) WordSpacing 

func (e *TagSvgLine) WordSpacing(value interface{}) (ref *TagSvgLine)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgLine) WritingMode 

func (e *TagSvgLine) WritingMode(value interface{}) (ref *TagSvgLine)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgLine) X1 

func (e *TagSvgLine) X1(value interface{}) (ref *TagSvgLine)

X1

English:

The x1 attribute is used to specify the first x-coordinate for drawing an SVG element that requires more than one coordinate. 

Input:
  value: specify the first x-coordinate
    float32: 1.0 = "100%"
    any other type: interface{}

Elements that only need one coordinate use the x attribute instead.

Português:

O atributo x1 é usado para especificar a primeira coordenada x para desenhar um elemento SVG que requer mais de uma coordenada. 

Input:
  value: especifique a primeira coordenada x
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Elementos que precisam apenas de uma coordenada usam o atributo x.

func (*TagSvgLine) X2 

func (e *TagSvgLine) X2(value interface{}) (ref *TagSvgLine)

X2

English:

The x2 attribute is used to specify the second x-coordinate for drawing an SVG element that requires more than one coordinate. Elements that only need one coordinate use the x attribute instead. 

Input:
  value: specify the second x-coordinate
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo x2 é usado para especificar a segunda coordenada x para desenhar um elemento SVG que requer mais de uma coordenada. Elementos que precisam apenas de uma coordenada usam o atributo x. 

Entrada:
  value: especifique a segunda coordenada x
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgLine) XmlLang 

func (e *TagSvgLine) XmlLang(value interface{}) (ref *TagSvgLine)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

func (*TagSvgLine) Y1 

func (e *TagSvgLine) Y1(value interface{}) (ref *TagSvgLine)

Y1

English:

The y1 attribute is used to specify the first y-coordinate for drawing an SVG element that requires more than one coordinate. 

Input:
  value: specify the first y-coordinate
    float32: 1.0 = "100%"
    any other type: interface{}

Elements that only need one coordinate use the y attribute instead.

Português:

O atributo y1 é usado para especificar a primeira coordenada y para desenhar um elemento SVG que requer mais de uma coordenada. 

Input:
  value: especifique a primeira coordenada y
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Elementos que precisam apenas de uma coordenada usam o atributo y.

func (*TagSvgLine) Y2 

func (e *TagSvgLine) Y2(value interface{}) (ref *TagSvgLine)

Y2

English:

The y2 attribute is used to specify the second y-coordinate for drawing an SVG element that requires more than one coordinate. 

Input:
  value: specify the second x-coordinate
    float32: 1.0 = "100%"
    any other type: interface{}

Elements that only need one coordinate use the x attribute instead.

Português:

O atributo y2 é usado para especificar a segunda coordenada y para desenhar um elemento SVG que requer mais de uma coordenada. 

Entrada:
  value: especifique a segunda coordenada x
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Elementos que precisam apenas de uma coordenada usam o atributo y.

type TagSvgLinearGradient 

type TagSvgLinearGradient struct {
	// contains filtered or unexported fields
}

TagSvgLinearGradient

English:

The <defs> element is used to store graphical objects that will be used at a later time.

Objects created inside a <defs> element are not rendered directly. To display them you have to reference them (with a <use> element for example).

Graphical objects can be referenced from anywhere, however, defining these objects inside of a <defs> element promotes understandability of the SVG content and is beneficial to the overall accessibility of the document.

Português:

O elemento <defs> é usado para armazenar objetos gráficos que serão usados posteriormente.

Objetos criados dentro de um elemento <defs> não são renderizados diretamente. Para exibi-los, você deve referenciá-los (com um elemento <use>, por exemplo).

Graphical objects can be referenced from anywhere, however, defining these objects inside of a <defs> element promotes understandability of the SVG content and is beneficial to the overall accessibility of the document.

func (*TagSvgLinearGradient) Append 

func (e *TagSvgLinearGradient) Append(elements ...Compatible) (ref *TagSvgLinearGradient)

func (*TagSvgLinearGradient) AppendById 

func (e *TagSvgLinearGradient) AppendById(appendId string) (ref *TagSvgLinearGradient)

func (*TagSvgLinearGradient) AppendToElement 

func (e *TagSvgLinearGradient) AppendToElement(el js.Value) (ref *TagSvgLinearGradient)

func (*TagSvgLinearGradient) AppendToStage 

func (e *TagSvgLinearGradient) AppendToStage() (ref *TagSvgLinearGradient)

func (*TagSvgLinearGradient) BaselineShift 

func (e *TagSvgLinearGradient) BaselineShift(baselineShift interface{}) (ref *TagSvgLinearGradient)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgLinearGradient) Class 

func (e *TagSvgLinearGradient) Class(class string) (ref *TagSvgLinearGradient)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgLinearGradient) ClipPath 

func (e *TagSvgLinearGradient) ClipPath(clipPath string) (ref *TagSvgLinearGradient)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgLinearGradient) ClipRule 

func (e *TagSvgLinearGradient) ClipRule(value interface{}) (ref *TagSvgLinearGradient)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgLinearGradient) Color 

func (e *TagSvgLinearGradient) Color(value interface{}) (ref *TagSvgLinearGradient)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgLinearGradient) ColorInterpolation 

func (e *TagSvgLinearGradient) ColorInterpolation(value interface{}) (ref *TagSvgLinearGradient)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgLinearGradient) ColorInterpolationFilters 

func (e *TagSvgLinearGradient) ColorInterpolationFilters(value interface{}) (ref *TagSvgLinearGradient)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgLinearGradient) CreateElement 

func (e *TagSvgLinearGradient) CreateElement() (ref *TagSvgLinearGradient)

func (*TagSvgLinearGradient) Cursor 

func (e *TagSvgLinearGradient) Cursor(cursor SvgCursor) (ref *TagSvgLinearGradient)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgLinearGradient) Direction 

func (e *TagSvgLinearGradient) Direction(direction SvgDirection) (ref *TagSvgLinearGradient)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgLinearGradient) Display 

func (e *TagSvgLinearGradient) Display(value interface{}) (ref *TagSvgLinearGradient)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgLinearGradient) DominantBaseline 

func (e *TagSvgLinearGradient) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgLinearGradient)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgLinearGradient) Fill 

func (e *TagSvgLinearGradient) Fill(value interface{}) (ref *TagSvgLinearGradient)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgLinearGradient) FillOpacity 

func (e *TagSvgLinearGradient) FillOpacity(value interface{}) (ref *TagSvgLinearGradient)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgLinearGradient) FillRule 

func (e *TagSvgLinearGradient) FillRule(fillRule SvgFillRule) (ref *TagSvgLinearGradient)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgLinearGradient) Filter 

func (e *TagSvgLinearGradient) Filter(filter string) (ref *TagSvgLinearGradient)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgLinearGradient) FloodColor 

func (e *TagSvgLinearGradient) FloodColor(floodColor interface{}) (ref *TagSvgLinearGradient)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgLinearGradient) FloodOpacity 

func (e *TagSvgLinearGradient) FloodOpacity(floodOpacity float64) (ref *TagSvgLinearGradient)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgLinearGradient) FontFamily 

func (e *TagSvgLinearGradient) FontFamily(fontFamily string) (ref *TagSvgLinearGradient)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgLinearGradient) FontSize 

func (e *TagSvgLinearGradient) FontSize(fontSize interface{}) (ref *TagSvgLinearGradient)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgLinearGradient) FontSizeAdjust 

func (e *TagSvgLinearGradient) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgLinearGradient)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgLinearGradient) FontStretch 

func (e *TagSvgLinearGradient) FontStretch(fontStretch interface{}) (ref *TagSvgLinearGradient)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgLinearGradient) FontStyle 

func (e *TagSvgLinearGradient) FontStyle(fontStyle FontStyleRule) (ref *TagSvgLinearGradient)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgLinearGradient) FontVariant 

func (e *TagSvgLinearGradient) FontVariant(value interface{}) (ref *TagSvgLinearGradient)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgLinearGradient) FontWeight 

func (e *TagSvgLinearGradient) FontWeight(value interface{}) (ref *TagSvgLinearGradient)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgLinearGradient) Get 

func (e *TagSvgLinearGradient) Get() (el js.Value)

func (*TagSvgLinearGradient) GradientTransform 

func (e *TagSvgLinearGradient) GradientTransform(value interface{}) (ref *TagSvgLinearGradient)

GradientTransform

English: 

The gradientTransform attribute contains the definition of an optional additional transformation from the gradient
coordinate system onto the target coordinate system (i.e., userSpaceOnUse or objectBoundingBox).

 Input:
   value: definition of an optional additional transformation from the gradient coordinate system
     Object: &html.TransformFunctions{}
     any other type: interface{}

This allows for things such as skewing the gradient. This additional transformation matrix is post-multiplied to
(i.e., inserted to the right of) any previously defined transformations, including the implicit transformation
necessary to convert from object bounding box units to user space.

Portuguese 

O atributo gradientTransform contém a definição de uma transformação adicional opcional do sistema de coordenadas
de gradiente para o sistema de coordenadas de destino (ou seja, userSpaceOnUse ou objectBoundingBox).

 Entrada:
   value: definição de uma transformação adicional opcional do sistema de coordenadas de gradiente
     Object: &html.TransformFunctions{}
     qualquer outro tipo: interface{}

Isso permite coisas como distorcer o gradiente. Essa matriz de transformação adicional é pós-multiplicada para
(ou seja, inserida à direita de) quaisquer transformações definidas anteriormente, incluindo a transformação
implícita necessária para converter de unidades de caixa delimitadora de objeto para espaço do usuário.

func (*TagSvgLinearGradient) GradientUnits 

func (e *TagSvgLinearGradient) GradientUnits(value interface{}) (ref *TagSvgLinearGradient)

GradientUnits

English: 

The gradientUnits attribute defines the coordinate system used for attributes specified on the gradient elements.

 Input:
   value: defines the coordinate system
     const: KSvgGradientUnits... (e.g. KSvgGradientUnitsUserSpaceOnUse)
     any other type: interface{}

Portuguese 

O atributo gradientUnits define o sistema de coordenadas usado para atributos especificados nos elementos
gradientes.

 Entrada:
   value: define o sistema de coordenadas
     const: KSvgGradientUnits... (ex. KSvgGradientUnitsUserSpaceOnUse)
     any other type: interface{}

func (*TagSvgLinearGradient) HRef 

func (e *TagSvgLinearGradient) HRef(href string) (ref *TagSvgLinearGradient)

HRef

English: 

The href attribute defines a link to a resource as a reference URL. The exact meaning of that link depends on the
context of each element using it.

 Notes:
   * Specifications before SVG 2 defined an xlink:href attribute, which is now rendered obsolete by the href
     attribute.
     If you need to support earlier browser versions, the deprecated xlink:href attribute can be used as a fallback
     in addition to the href attribute, e.g. <use href="some-id" xlink:href="some-id x="5" y="5" />.

Português: 

O atributo href define um link para um recurso como um URL de referência. O significado exato desse link depende do
contexto de cada elemento que o utiliza.

 Notas:
   * As especificações anteriores ao SVG 2 definiam um atributo xlink:href, que agora se torna obsoleto pelo
     atributo href.
     Se você precisar oferecer suporte a versões anteriores do navegador, o atributo obsoleto xlink:href pode ser
     usado como um substituto além do atributo href, por exemplo,
     <use href="some-id" xlink:href="some-id x="5" y="5" />.

func (*TagSvgLinearGradient) Html 

func (e *TagSvgLinearGradient) Html(value string) (ref *TagSvgLinearGradient)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgLinearGradient) Id 

func (e *TagSvgLinearGradient) Id(id string) (ref *TagSvgLinearGradient)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgLinearGradient) ImageRendering 

func (e *TagSvgLinearGradient) ImageRendering(imageRendering string) (ref *TagSvgLinearGradient)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgLinearGradient) Init 

func (e *TagSvgLinearGradient) Init() (ref *TagSvgLinearGradient)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgLinearGradient) Lang 

func (e *TagSvgLinearGradient) Lang(value interface{}) (ref *TagSvgLinearGradient)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgLinearGradient) LetterSpacing 

func (e *TagSvgLinearGradient) LetterSpacing(value float64) (ref *TagSvgLinearGradient)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgLinearGradient) LightingColor 

func (e *TagSvgLinearGradient) LightingColor(value interface{}) (ref *TagSvgLinearGradient)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgLinearGradient) MarkerEnd 

func (e *TagSvgLinearGradient) MarkerEnd(value interface{}) (ref *TagSvgLinearGradient)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgLinearGradient) MarkerMid 

func (e *TagSvgLinearGradient) MarkerMid(value interface{}) (ref *TagSvgLinearGradient)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgLinearGradient) MarkerStart 

func (e *TagSvgLinearGradient) MarkerStart(value interface{}) (ref *TagSvgLinearGradient)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgLinearGradient) Mask 

func (e *TagSvgLinearGradient) Mask(value interface{}) (ref *TagSvgLinearGradient)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgLinearGradient) Opacity 

func (e *TagSvgLinearGradient) Opacity(value interface{}) (ref *TagSvgLinearGradient)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgLinearGradient) Overflow 

func (e *TagSvgLinearGradient) Overflow(value interface{}) (ref *TagSvgLinearGradient)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgLinearGradient) PointerEvents 

func (e *TagSvgLinearGradient) PointerEvents(value interface{}) (ref *TagSvgLinearGradient)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgLinearGradient) ShapeRendering 

func (e *TagSvgLinearGradient) ShapeRendering(value interface{}) (ref *TagSvgLinearGradient)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgLinearGradient) SpreadMethod 

func (e *TagSvgLinearGradient) SpreadMethod(value interface{}) (ref *TagSvgLinearGradient)

SpreadMethod

English:

The spreadMethod attribute determines how a shape is filled beyond the defined edges of a gradient. 

Input:
  value: determines how a shape is filled
    const: KSvgSpreadMethod... (e.g. KSvgSpreadMethodReflect)
    any other type: interface{}

Português:

O atributo spreadMethod determina como uma forma é preenchida além das bordas definidas de um gradiente. 

Entrada:
  value: determina como uma forma é preenchida
    const: KSvgSpreadMethod... (e.g. KSvgSpreadMethodReflect)
    qualquer outro tipo: interface{}

func (*TagSvgLinearGradient) StopColor 

func (e *TagSvgLinearGradient) StopColor(value interface{}) (ref *TagSvgLinearGradient)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgLinearGradient) StopOpacity 

func (e *TagSvgLinearGradient) StopOpacity(value interface{}) (ref *TagSvgLinearGradient)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgLinearGradient) Stroke 

func (e *TagSvgLinearGradient) Stroke(value interface{}) (ref *TagSvgLinearGradient)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgLinearGradient) StrokeDasharray 

func (e *TagSvgLinearGradient) StrokeDasharray(value interface{}) (ref *TagSvgLinearGradient)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgLinearGradient) StrokeLineCap 

func (e *TagSvgLinearGradient) StrokeLineCap(value interface{}) (ref *TagSvgLinearGradient)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgLinearGradient) StrokeLineJoin 

func (e *TagSvgLinearGradient) StrokeLineJoin(value interface{}) (ref *TagSvgLinearGradient)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgLinearGradient) StrokeMiterLimit 

func (e *TagSvgLinearGradient) StrokeMiterLimit(value float64) (ref *TagSvgLinearGradient)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgLinearGradient) StrokeOpacity 

func (e *TagSvgLinearGradient) StrokeOpacity(value interface{}) (ref *TagSvgLinearGradient)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgLinearGradient) StrokeWidth 

func (e *TagSvgLinearGradient) StrokeWidth(value interface{}) (ref *TagSvgLinearGradient)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgLinearGradient) Style 

func (e *TagSvgLinearGradient) Style(value string) (ref *TagSvgLinearGradient)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgLinearGradient) Tabindex 

func (e *TagSvgLinearGradient) Tabindex(value int) (ref *TagSvgLinearGradient)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgLinearGradient) Text 

func (e *TagSvgLinearGradient) Text(value string) (ref *TagSvgLinearGradient)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgLinearGradient) TextAnchor 

func (e *TagSvgLinearGradient) TextAnchor(value interface{}) (ref *TagSvgLinearGradient)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgLinearGradient) TextDecoration 

func (e *TagSvgLinearGradient) TextDecoration(value interface{}) (ref *TagSvgLinearGradient)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgLinearGradient) TextRendering 

func (e *TagSvgLinearGradient) TextRendering(value interface{}) (ref *TagSvgLinearGradient)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgLinearGradient) Transform 

func (e *TagSvgLinearGradient) Transform(value interface{}) (ref *TagSvgLinearGradient)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgLinearGradient) UnicodeBidi 

func (e *TagSvgLinearGradient) UnicodeBidi(value interface{}) (ref *TagSvgLinearGradient)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgLinearGradient) VectorEffect 

func (e *TagSvgLinearGradient) VectorEffect(value interface{}) (ref *TagSvgLinearGradient)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgLinearGradient) Visibility 

func (e *TagSvgLinearGradient) Visibility(value interface{}) (ref *TagSvgLinearGradient)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgLinearGradient) WordSpacing 

func (e *TagSvgLinearGradient) WordSpacing(value interface{}) (ref *TagSvgLinearGradient)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgLinearGradient) WritingMode 

func (e *TagSvgLinearGradient) WritingMode(value interface{}) (ref *TagSvgLinearGradient)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgLinearGradient) X1 

func (e *TagSvgLinearGradient) X1(value interface{}) (ref *TagSvgLinearGradient)

X1

English:

The x1 attribute is used to specify the first x-coordinate for drawing an SVG element that requires more than one coordinate. 

Input:
  value: specify the first x-coordinate
    float32: 1.0 = "100%"
    any other type: interface{}

Elements that only need one coordinate use the x attribute instead.

Português:

O atributo x1 é usado para especificar a primeira coordenada x para desenhar um elemento SVG que requer mais de uma coordenada. 

Input:
  value: especifique a primeira coordenada x
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Elementos que precisam apenas de uma coordenada usam o atributo x.

func (*TagSvgLinearGradient) X2 

func (e *TagSvgLinearGradient) X2(value interface{}) (ref *TagSvgLinearGradient)

X2

English:

The x2 attribute is used to specify the second x-coordinate for drawing an SVG element that requires more than one coordinate. Elements that only need one coordinate use the x attribute instead. 

Input:
  value: specify the second x-coordinate
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo x2 é usado para especificar a segunda coordenada x para desenhar um elemento SVG que requer mais de uma coordenada. Elementos que precisam apenas de uma coordenada usam o atributo x. 

Entrada:
  value: especifique a segunda coordenada x
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgLinearGradient) XLinkHRef deprecated 

func (e *TagSvgLinearGradient) XLinkHRef(value interface{}) (ref *TagSvgLinearGradient)

XLinkHRef

English:

Deprecated: use HRef() function

The xlink:href attribute defines a reference to a resource as a reference IRI. The exact meaning of that link depends on the context of each element using it. 

Notes:
  * SVG 2 removed the need for the xlink namespace, so instead of xlink:href you should use href. If you need to
    support earlier browser versions, the deprecated xlink:href attribute can be used as a fallback in addition to
    the href attribute, e.g. <use href="some-id" xlink:href="some-id" x="5" y="5" />.

Português:

Obsoleto: use a função HRef()

O atributo xlink:href define uma referência a um recurso como um IRI de referência. O significado exato desse link depende do contexto de cada elemento que o utiliza. 

Notas:
  * O SVG 2 removeu a necessidade do namespace xlink, então ao invés de xlink:href você deve usar href. Se você
    precisar oferecer suporte a versões anteriores do navegador, o atributo obsoleto xlink:href pode ser usado como
    um substituto além do atributo href, por exemplo, <use href="some-id" xlink:href="some-id" x="5" y="5" >.

func (*TagSvgLinearGradient) XmlLang 

func (e *TagSvgLinearGradient) XmlLang(value interface{}) (ref *TagSvgLinearGradient)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

func (*TagSvgLinearGradient) Y1 

func (e *TagSvgLinearGradient) Y1(value interface{}) (ref *TagSvgLinearGradient)

Y1

English:

The y1 attribute is used to specify the first y-coordinate for drawing an SVG element that requires more than one coordinate. 

Input:
  value: specify the first y-coordinate
    float32: 1.0 = "100%"
    any other type: interface{}

Elements that only need one coordinate use the y attribute instead.

Português:

O atributo y1 é usado para especificar a primeira coordenada y para desenhar um elemento SVG que requer mais de uma coordenada. 

Input:
  value: especifique a primeira coordenada y
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Elementos que precisam apenas de uma coordenada usam o atributo y.

func (*TagSvgLinearGradient) Y2 

func (e *TagSvgLinearGradient) Y2(value interface{}) (ref *TagSvgLinearGradient)

Y2

English:

The y2 attribute is used to specify the second y-coordinate for drawing an SVG element that requires more than one coordinate. 

Input:
  value: specify the second x-coordinate
    float32: 1.0 = "100%"
    any other type: interface{}

Elements that only need one coordinate use the x attribute instead.

Português:

O atributo y2 é usado para especificar a segunda coordenada y para desenhar um elemento SVG que requer mais de uma coordenada. 

Entrada:
  value: especifique a segunda coordenada x
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Elementos que precisam apenas de uma coordenada usam o atributo y.

type TagSvgMPath 

type TagSvgMPath struct {
	// contains filtered or unexported fields
}

TagSvgMPath

English:

The <metadata> SVG element adds metadata to SVG content. Metadata is structured information about data. The contents of <metadata> should be elements from other XML namespaces such as RDF, FOAF, etc.

Português:

O elemento SVG <metadata> adiciona metadados ao conteúdo SVG. Metadados são informações estruturadas sobre dados. O conteúdo de <metadata> deve ser elementos de outros namespaces XML, como RDF, FOAF, etc.

func (*TagSvgMPath) Append 

func (e *TagSvgMPath) Append(elements ...Compatible) (ref *TagSvgMPath)

func (*TagSvgMPath) AppendById 

func (e *TagSvgMPath) AppendById(appendId string) (ref *TagSvgMPath)

func (*TagSvgMPath) AppendToElement 

func (e *TagSvgMPath) AppendToElement(el js.Value) (ref *TagSvgMPath)

func (*TagSvgMPath) AppendToStage 

func (e *TagSvgMPath) AppendToStage() (ref *TagSvgMPath)

func (*TagSvgMPath) CreateElement 

func (e *TagSvgMPath) CreateElement() (ref *TagSvgMPath)

func (*TagSvgMPath) Get 

func (e *TagSvgMPath) Get() (el js.Value)

func (*TagSvgMPath) HRef 

func (e *TagSvgMPath) HRef(href string) (ref *TagSvgMPath)

HRef

English: 

The href attribute defines a link to a resource as a reference URL. The exact meaning of that link depends on the
context of each element using it.

 Notes:
   * Specifications before SVG 2 defined an xlink:href attribute, which is now rendered obsolete by the href
     attribute.
     If you need to support earlier browser versions, the deprecated xlink:href attribute can be used as a fallback
     in addition to the href attribute, e.g. <use href="some-id" xlink:href="some-id x="5" y="5" />.

Português: 

O atributo href define um link para um recurso como um URL de referência. O significado exato desse link depende do
contexto de cada elemento que o utiliza.

 Notas:
   * As especificações anteriores ao SVG 2 definiam um atributo xlink:href, que agora se torna obsoleto pelo
     atributo href.
     Se você precisar oferecer suporte a versões anteriores do navegador, o atributo obsoleto xlink:href pode ser
     usado como um substituto além do atributo href, por exemplo,
     <use href="some-id" xlink:href="some-id x="5" y="5" />.

func (*TagSvgMPath) Html 

func (e *TagSvgMPath) Html(value string) (ref *TagSvgMPath)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgMPath) Id 

func (e *TagSvgMPath) Id(id string) (ref *TagSvgMPath)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgMPath) Init 

func (e *TagSvgMPath) Init() (ref *TagSvgMPath)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgMPath) Lang 

func (e *TagSvgMPath) Lang(value interface{}) (ref *TagSvgMPath)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgMPath) Tabindex 

func (e *TagSvgMPath) Tabindex(value int) (ref *TagSvgMPath)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgMPath) Text 

func (e *TagSvgMPath) Text(value string) (ref *TagSvgMPath)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgMPath) XLinkHRef deprecated 

func (e *TagSvgMPath) XLinkHRef(value interface{}) (ref *TagSvgMPath)

XLinkHRef

English:

Deprecated: use HRef() function

The xlink:href attribute defines a reference to a resource as a reference IRI. The exact meaning of that link depends on the context of each element using it. 

Notes:
  * SVG 2 removed the need for the xlink namespace, so instead of xlink:href you should use href. If you need to
    support earlier browser versions, the deprecated xlink:href attribute can be used as a fallback in addition to
    the href attribute, e.g. <use href="some-id" xlink:href="some-id" x="5" y="5" />.

Português:

Obsoleto: use a função HRef()

O atributo xlink:href define uma referência a um recurso como um IRI de referência. O significado exato desse link depende do contexto de cada elemento que o utiliza. 

Notas:
  * O SVG 2 removeu a necessidade do namespace xlink, então ao invés de xlink:href você deve usar href. Se você
    precisar oferecer suporte a versões anteriores do navegador, o atributo obsoleto xlink:href pode ser usado como
    um substituto além do atributo href, por exemplo, <use href="some-id" xlink:href="some-id" x="5" y="5" >.

func (*TagSvgMPath) XmlLang 

func (e *TagSvgMPath) XmlLang(value interface{}) (ref *TagSvgMPath)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

type TagSvgMarker 

type TagSvgMarker struct {
	// contains filtered or unexported fields
}

TagSvgMarker

English:

The <marker> element defines the graphic that is to be used for drawing arrowheads or polymarkers on a given <path>, <line>, <polyline> or <polygon> element.

Markers are attached to shapes using the marker-start, marker-mid, and marker-end properties.

Português:

O elemento <marker> define o gráfico que deve ser usado para desenhar pontas de seta ou polimarcadores em um determinado elemento <path>, <line>, <polyline> ou <polygon>.

Os marcadores são anexados às formas usando as propriedades de início do marcador, meio do marcador e final do marcador.

func (*TagSvgMarker) Append 

func (e *TagSvgMarker) Append(elements ...Compatible) (ref *TagSvgMarker)

func (*TagSvgMarker) AppendById 

func (e *TagSvgMarker) AppendById(appendId string) (ref *TagSvgMarker)

func (*TagSvgMarker) AppendToElement 

func (e *TagSvgMarker) AppendToElement(el js.Value) (ref *TagSvgMarker)

func (*TagSvgMarker) AppendToStage 

func (e *TagSvgMarker) AppendToStage() (ref *TagSvgMarker)

func (*TagSvgMarker) BaselineShift 

func (e *TagSvgMarker) BaselineShift(baselineShift interface{}) (ref *TagSvgMarker)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgMarker) Class 

func (e *TagSvgMarker) Class(class string) (ref *TagSvgMarker)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgMarker) ClipPath 

func (e *TagSvgMarker) ClipPath(clipPath string) (ref *TagSvgMarker)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgMarker) ClipRule 

func (e *TagSvgMarker) ClipRule(value interface{}) (ref *TagSvgMarker)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgMarker) Color 

func (e *TagSvgMarker) Color(value interface{}) (ref *TagSvgMarker)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgMarker) ColorInterpolation 

func (e *TagSvgMarker) ColorInterpolation(value interface{}) (ref *TagSvgMarker)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgMarker) ColorInterpolationFilters 

func (e *TagSvgMarker) ColorInterpolationFilters(value interface{}) (ref *TagSvgMarker)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgMarker) CreateElement 

func (e *TagSvgMarker) CreateElement() (ref *TagSvgMarker)

func (*TagSvgMarker) Cursor 

func (e *TagSvgMarker) Cursor(cursor SvgCursor) (ref *TagSvgMarker)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgMarker) Direction 

func (e *TagSvgMarker) Direction(direction SvgDirection) (ref *TagSvgMarker)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgMarker) Display 

func (e *TagSvgMarker) Display(value interface{}) (ref *TagSvgMarker)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgMarker) DominantBaseline 

func (e *TagSvgMarker) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgMarker)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgMarker) Fill 

func (e *TagSvgMarker) Fill(value interface{}) (ref *TagSvgMarker)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgMarker) FillOpacity 

func (e *TagSvgMarker) FillOpacity(value interface{}) (ref *TagSvgMarker)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgMarker) FillRule 

func (e *TagSvgMarker) FillRule(fillRule SvgFillRule) (ref *TagSvgMarker)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgMarker) Filter 

func (e *TagSvgMarker) Filter(filter string) (ref *TagSvgMarker)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgMarker) FloodColor 

func (e *TagSvgMarker) FloodColor(floodColor interface{}) (ref *TagSvgMarker)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgMarker) FloodOpacity 

func (e *TagSvgMarker) FloodOpacity(floodOpacity float64) (ref *TagSvgMarker)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgMarker) FontFamily 

func (e *TagSvgMarker) FontFamily(fontFamily string) (ref *TagSvgMarker)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgMarker) FontSize 

func (e *TagSvgMarker) FontSize(fontSize interface{}) (ref *TagSvgMarker)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgMarker) FontSizeAdjust 

func (e *TagSvgMarker) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgMarker)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgMarker) FontStretch 

func (e *TagSvgMarker) FontStretch(fontStretch interface{}) (ref *TagSvgMarker)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgMarker) FontStyle 

func (e *TagSvgMarker) FontStyle(fontStyle FontStyleRule) (ref *TagSvgMarker)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgMarker) FontVariant 

func (e *TagSvgMarker) FontVariant(value interface{}) (ref *TagSvgMarker)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgMarker) FontWeight 

func (e *TagSvgMarker) FontWeight(value interface{}) (ref *TagSvgMarker)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgMarker) Get 

func (e *TagSvgMarker) Get() (el js.Value)

func (*TagSvgMarker) Html 

func (e *TagSvgMarker) Html(value string) (ref *TagSvgMarker)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgMarker) Id 

func (e *TagSvgMarker) Id(id string) (ref *TagSvgMarker)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgMarker) ImageRendering 

func (e *TagSvgMarker) ImageRendering(imageRendering string) (ref *TagSvgMarker)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgMarker) Init 

func (e *TagSvgMarker) Init() (ref *TagSvgMarker)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgMarker) Lang 

func (e *TagSvgMarker) Lang(value interface{}) (ref *TagSvgMarker)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgMarker) LetterSpacing 

func (e *TagSvgMarker) LetterSpacing(value float64) (ref *TagSvgMarker)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgMarker) LightingColor 

func (e *TagSvgMarker) LightingColor(value interface{}) (ref *TagSvgMarker)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgMarker) MarkerEnd 

func (e *TagSvgMarker) MarkerEnd(value interface{}) (ref *TagSvgMarker)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgMarker) MarkerHeight 

func (e *TagSvgMarker) MarkerHeight(value interface{}) (ref *TagSvgMarker)

MarkerHeight

English:

The markerHeight attribute represents the height of the viewport into which the <marker> is to be fitted when it is rendered according to the viewBox and preserveAspectRatio attributes. 

Input:
  value: represents the height of the viewport
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo markerHeight representa a altura da viewport na qual o <marker> deve ser ajustado quando for renderizado de acordo com os atributos viewBox e preserveAspectRatio. 

Entrada:
  value: representa a altura da janela de visualização
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgMarker) MarkerMid 

func (e *TagSvgMarker) MarkerMid(value interface{}) (ref *TagSvgMarker)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgMarker) MarkerStart 

func (e *TagSvgMarker) MarkerStart(value interface{}) (ref *TagSvgMarker)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgMarker) MarkerUnits 

func (e *TagSvgMarker) MarkerUnits(value interface{}) (ref *TagSvgMarker)

MarkerUnits

English:

The markerUnits attribute defines the coordinate system for the markerWidth and markerHeight attributes and the contents of the <marker>. 

Input:
  value: defines the coordinate system
    const KSvgMarkerUnits... (e.g. KSvgMarkerUnitsUserSpaceOnUse)

Português:

O atributo markerUnits define o sistema de coordenadas para os atributos markerWidth e markerHeight e o conteúdo do <marker>. 

Entrada:
  value: define o sistema de coordenadas
    const KSvgMarkerUnits... (ex. KSvgMarkerUnitsUserSpaceOnUse)

func (*TagSvgMarker) MarkerWidth 

func (e *TagSvgMarker) MarkerWidth(value interface{}) (ref *TagSvgMarker)

MarkerWidth

English:

The markerWidth attribute represents the width of the viewport into which the <marker> is to be fitted when it is rendered according to the viewBox and preserveAspectRatio attributes. 

Input:
  value: represents the width of the viewport
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo markerWidth representa a largura da viewport na qual o <marker> deve ser ajustado quando for renderizado de acordo com os atributos viewBox e preserveAspectRatio. 

Input:
  value: representa a largura da janela de visualização
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgMarker) Mask 

func (e *TagSvgMarker) Mask(value interface{}) (ref *TagSvgMarker)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgMarker) Opacity 

func (e *TagSvgMarker) Opacity(value interface{}) (ref *TagSvgMarker)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgMarker) Orient 

func (e *TagSvgMarker) Orient(value interface{}) (ref *TagSvgMarker)

Orient

English:

The orient attribute indicates how a marker is rotated when it is placed at its position on the shape. 

Input:
  value: indicates how a marker is rotated
    const: KSvgOrient... (e.g. KSvgOrientAuto)
    Degrees: Degrees(-65) = "-65deg"
    any other type: interface{}

Português:

O atributo orient indica como um marcador é girado quando é colocado em sua posição na forma. 

Entrada:
  value: indica como um marcador é girado
    const: KSvgOrient... (ex. KSvgOrientAuto)
    Degrees: Degrees(-65) = "-65deg"
    qualquer outro tipo: interface{}

func (*TagSvgMarker) Overflow 

func (e *TagSvgMarker) Overflow(value interface{}) (ref *TagSvgMarker)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgMarker) PointerEvents 

func (e *TagSvgMarker) PointerEvents(value interface{}) (ref *TagSvgMarker)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgMarker) PreserveAspectRatio 

func (e *TagSvgMarker) PreserveAspectRatio(ratio, meet interface{}) (ref *TagSvgMarker)

PreserveAspectRatio

English: 

The preserveAspectRatio attribute indicates how an element with a viewBox providing a given aspect ratio must fit
into a viewport with a different aspect ratio.

 Input:
   ratio: Indicates how an element with a viewBox providing a given aspect ratio.
     const: KRatio... (e.g. KRatioXMinYMin)
     any other type: interface{}
   meet: The meet or slice reference
     const: KMeetOrSliceReference... (e.g. KMeetOrSliceReferenceSlice)
     any other type: interface{}

Because the aspect ratio of an SVG image is defined by the viewBox attribute, if this attribute isn't set, the preserveAspectRatio attribute has no effect (with one exception, the <image> element, as described below).

Português: 

O atributo preserveAspectRatio indica como um elemento com uma viewBox fornecendo uma determinada proporção deve
caber em uma viewport com uma proporção diferente.

 Input:
   ratio: Indica como um elemento com uma viewBox fornece uma determinada proporção.
     const: KRatio... (ex. KRatioXMinYMin)
     qualquer outro tipo: interface{}
   meet: A referência de encontro ou fatia
     const: KMeetOrSliceReference... (ex. KMeetOrSliceReferenceSlice)
     qualquer outro tipo: interface{}

Como a proporção de uma imagem SVG é definida pelo atributo viewBox, se esse atributo não estiver definido, o atributo preserveAspectRatio não terá efeito (com uma exceção, o elemento <image>, conforme descrito abaixo).

func (*TagSvgMarker) RefX 

func (e *TagSvgMarker) RefX(value interface{}) (ref *TagSvgMarker)

RefX

English:

The refX attribute defines the x coordinate of an element's reference point. 

Input:
  value: defines the x coordinate of an element's reference point
    float32: 1.0 = "100%"
    const: KPositionHorizontal... (e.g. KPositionHorizontalLeft)
    any other type: interface{}

Português:

O atributo refX define a coordenada x do ponto de referência de um elemento. 

Entrada:
  value: define a coordenada x do ponto de referência de um elemento
    float32: 1.0 = "100%"
    const: KPositionHorizontal... (ex. KPositionHorizontalLeft)
    qualquer outro tipo: interface{}

func (*TagSvgMarker) RefY 

func (e *TagSvgMarker) RefY(value interface{}) (ref *TagSvgMarker)

RefY

English:

The refX attribute defines the y coordinate of an element's reference point. 

Input:
  value: defines the y coordinate of an element's reference point
    float32: 1.0 = "100%"
    const: KPositionVertical... (e.g. KPositionVerticalTop)
    any other type: interface{}

Português:

O atributo refX define a coordenada y do ponto de referência de um elemento. 

Entrada:
  value: define a coordenada y do ponto de referência de um elemento
    float32: 1.0 = "100%"
    const: KPositionVertical... (ex. KPositionVerticalTop)
    qualquer outro tipo: interface{}

func (*TagSvgMarker) ShapeRendering 

func (e *TagSvgMarker) ShapeRendering(value interface{}) (ref *TagSvgMarker)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgMarker) StopColor 

func (e *TagSvgMarker) StopColor(value interface{}) (ref *TagSvgMarker)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgMarker) StopOpacity 

func (e *TagSvgMarker) StopOpacity(value interface{}) (ref *TagSvgMarker)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgMarker) Stroke 

func (e *TagSvgMarker) Stroke(value interface{}) (ref *TagSvgMarker)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgMarker) StrokeDasharray 

func (e *TagSvgMarker) StrokeDasharray(value interface{}) (ref *TagSvgMarker)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgMarker) StrokeLineCap 

func (e *TagSvgMarker) StrokeLineCap(value interface{}) (ref *TagSvgMarker)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgMarker) StrokeLineJoin 

func (e *TagSvgMarker) StrokeLineJoin(value interface{}) (ref *TagSvgMarker)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgMarker) StrokeMiterLimit 

func (e *TagSvgMarker) StrokeMiterLimit(value float64) (ref *TagSvgMarker)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgMarker) StrokeOpacity 

func (e *TagSvgMarker) StrokeOpacity(value interface{}) (ref *TagSvgMarker)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgMarker) StrokeWidth 

func (e *TagSvgMarker) StrokeWidth(value interface{}) (ref *TagSvgMarker)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgMarker) Style 

func (e *TagSvgMarker) Style(value string) (ref *TagSvgMarker)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgMarker) Tabindex 

func (e *TagSvgMarker) Tabindex(value int) (ref *TagSvgMarker)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgMarker) Text 

func (e *TagSvgMarker) Text(value string) (ref *TagSvgMarker)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgMarker) TextAnchor 

func (e *TagSvgMarker) TextAnchor(value interface{}) (ref *TagSvgMarker)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgMarker) TextDecoration 

func (e *TagSvgMarker) TextDecoration(value interface{}) (ref *TagSvgMarker)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgMarker) TextRendering 

func (e *TagSvgMarker) TextRendering(value interface{}) (ref *TagSvgMarker)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgMarker) Transform 

func (e *TagSvgMarker) Transform(value interface{}) (ref *TagSvgMarker)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgMarker) UnicodeBidi 

func (e *TagSvgMarker) UnicodeBidi(value interface{}) (ref *TagSvgMarker)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgMarker) VectorEffect 

func (e *TagSvgMarker) VectorEffect(value interface{}) (ref *TagSvgMarker)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgMarker) ViewBox 

func (e *TagSvgMarker) ViewBox(value interface{}) (ref *TagSvgMarker)

ViewBox

English:

The viewBox attribute defines the position and dimension, in user space, of an SVG viewport. 

Input:
  value: defines the position and dimension, in user space, of an SVG viewport
    []float64: ex. []float64{0.0, 0.0, 10.0, 10.0} = "0 0 10 10"
    any other type: interface{}

The value of the viewBox attribute is a list of four numbers: min-x, min-y, width and height. The numbers, which are separated by whitespace and/or a comma, specify a rectangle in user space which is mapped to the bounds of the viewport established for the associated SVG element (not the browser viewport).

Português:

O atributo viewBox define a posição e a dimensão, no espaço do usuário, de uma viewport SVG. 

Input:
  value: define a posição e dimensão, no espaço do usuário, de uma viewport SVG
    []float64: ex. []float64{0.0, 0.0, 10.0, 10.0} = "0 0 10 10"
    qualquer outro tipo: interface{}

O valor do atributo viewBox é uma lista de quatro números: min-x, min-y, largura e altura. Os números, que são separados por espaço em branco e ou vírgula, especificam um retângulo no espaço do usuário que é mapeado para os limites da janela de visualização estabelecida para o elemento SVG associado (não a janela de visualização do navegador).

func (*TagSvgMarker) Visibility 

func (e *TagSvgMarker) Visibility(value interface{}) (ref *TagSvgMarker)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgMarker) WordSpacing 

func (e *TagSvgMarker) WordSpacing(value interface{}) (ref *TagSvgMarker)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgMarker) WritingMode 

func (e *TagSvgMarker) WritingMode(value interface{}) (ref *TagSvgMarker)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgMarker) XmlLang 

func (e *TagSvgMarker) XmlLang(value interface{}) (ref *TagSvgMarker)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

type TagSvgMask 

type TagSvgMask struct {
	// contains filtered or unexported fields
}

TagSvgMask

English:

The <mask> element defines an alpha mask for compositing the current object into the background. A mask is used/referenced using the mask property.

Português:

O elemento <mask> define uma máscara alfa para compor o objeto atual em segundo plano. Uma máscara é used/referenced usando a propriedade mask.

func (*TagSvgMask) Append 

func (e *TagSvgMask) Append(elements ...Compatible) (ref *TagSvgMask)

func (*TagSvgMask) AppendById 

func (e *TagSvgMask) AppendById(appendId string) (ref *TagSvgMask)

func (*TagSvgMask) AppendToElement 

func (e *TagSvgMask) AppendToElement(el js.Value) (ref *TagSvgMask)

func (*TagSvgMask) AppendToStage 

func (e *TagSvgMask) AppendToStage() (ref *TagSvgMask)

func (*TagSvgMask) BaselineShift 

func (e *TagSvgMask) BaselineShift(baselineShift interface{}) (ref *TagSvgMask)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgMask) Class 

func (e *TagSvgMask) Class(class string) (ref *TagSvgMask)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgMask) ClipPath 

func (e *TagSvgMask) ClipPath(clipPath string) (ref *TagSvgMask)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgMask) ClipRule 

func (e *TagSvgMask) ClipRule(value interface{}) (ref *TagSvgMask)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgMask) Color 

func (e *TagSvgMask) Color(value interface{}) (ref *TagSvgMask)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgMask) ColorInterpolation 

func (e *TagSvgMask) ColorInterpolation(value interface{}) (ref *TagSvgMask)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgMask) ColorInterpolationFilters 

func (e *TagSvgMask) ColorInterpolationFilters(value interface{}) (ref *TagSvgMask)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgMask) CreateElement 

func (e *TagSvgMask) CreateElement() (ref *TagSvgMask)

func (*TagSvgMask) Cursor 

func (e *TagSvgMask) Cursor(cursor SvgCursor) (ref *TagSvgMask)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgMask) Direction 

func (e *TagSvgMask) Direction(direction SvgDirection) (ref *TagSvgMask)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgMask) Display 

func (e *TagSvgMask) Display(value interface{}) (ref *TagSvgMask)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgMask) DominantBaseline 

func (e *TagSvgMask) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgMask)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgMask) Fill 

func (e *TagSvgMask) Fill(value interface{}) (ref *TagSvgMask)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgMask) FillOpacity 

func (e *TagSvgMask) FillOpacity(value interface{}) (ref *TagSvgMask)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgMask) FillRule 

func (e *TagSvgMask) FillRule(fillRule SvgFillRule) (ref *TagSvgMask)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgMask) Filter 

func (e *TagSvgMask) Filter(filter string) (ref *TagSvgMask)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgMask) FloodColor 

func (e *TagSvgMask) FloodColor(floodColor interface{}) (ref *TagSvgMask)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgMask) FloodOpacity 

func (e *TagSvgMask) FloodOpacity(floodOpacity float64) (ref *TagSvgMask)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgMask) FontFamily 

func (e *TagSvgMask) FontFamily(fontFamily string) (ref *TagSvgMask)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgMask) FontSize 

func (e *TagSvgMask) FontSize(fontSize interface{}) (ref *TagSvgMask)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgMask) FontSizeAdjust 

func (e *TagSvgMask) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgMask)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgMask) FontStretch 

func (e *TagSvgMask) FontStretch(fontStretch interface{}) (ref *TagSvgMask)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgMask) FontStyle 

func (e *TagSvgMask) FontStyle(fontStyle FontStyleRule) (ref *TagSvgMask)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgMask) FontVariant 

func (e *TagSvgMask) FontVariant(value interface{}) (ref *TagSvgMask)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgMask) FontWeight 

func (e *TagSvgMask) FontWeight(value interface{}) (ref *TagSvgMask)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgMask) Get 

func (e *TagSvgMask) Get() (el js.Value)

func (*TagSvgMask) Height 

func (e *TagSvgMask) Height(height interface{}) (ref *TagSvgMask)

Height

English: 

The height attribute defines the vertical length of an element in the user coordinate system.
     float32: 1.0 = "100%"
     any other type: interface{}

Português: 

O atributo height define o comprimento vertical de um elemento no sistema de coordenadas do usuário.
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

func (*TagSvgMask) Html 

func (e *TagSvgMask) Html(value string) (ref *TagSvgMask)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgMask) Id 

func (e *TagSvgMask) Id(id string) (ref *TagSvgMask)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgMask) ImageRendering 

func (e *TagSvgMask) ImageRendering(imageRendering string) (ref *TagSvgMask)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgMask) Init 

func (e *TagSvgMask) Init() (ref *TagSvgMask)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgMask) Lang 

func (e *TagSvgMask) Lang(value interface{}) (ref *TagSvgMask)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgMask) LetterSpacing 

func (e *TagSvgMask) LetterSpacing(value float64) (ref *TagSvgMask)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgMask) LightingColor 

func (e *TagSvgMask) LightingColor(value interface{}) (ref *TagSvgMask)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgMask) MarkerEnd 

func (e *TagSvgMask) MarkerEnd(value interface{}) (ref *TagSvgMask)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgMask) MarkerMid 

func (e *TagSvgMask) MarkerMid(value interface{}) (ref *TagSvgMask)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgMask) MarkerStart 

func (e *TagSvgMask) MarkerStart(value interface{}) (ref *TagSvgMask)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgMask) Mask 

func (e *TagSvgMask) Mask(value interface{}) (ref *TagSvgMask)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgMask) MaskContentUnits 

func (e *TagSvgMask) MaskContentUnits(value interface{}) (ref *TagSvgMask)

MaskContentUnits

English:

The maskContentUnits attribute indicates which coordinate system to use for the contents of the <mask> element. 

Input:
  value: specifies the coordinate system
    const KSvgUnits... (e.g. KSvgUnitsObjectBoundingBox)
    any other type: interface{}

Português:

O atributo maskContentUnits indica qual sistema de coordenadas usar para o conteúdo do elemento <mask>. 

Entrada:
  value: especifica o sistema de coordenadas
    const KSvgUnits... (e.g. KSvgUnitsObjectBoundingBox)
    qualquer outro tipo: interface{}

func (*TagSvgMask) MaskUnits 

func (e *TagSvgMask) MaskUnits(value interface{}) (ref *TagSvgMask)

MaskUnits

English:

The maskUnits attribute indicates which coordinate system to use for the geometry properties of the <mask> element. 

Input:
  value: specifies the coordinate system
    const KSvgUnits... (e.g. KSvgUnitsObjectBoundingBox)
    any other type: interface{}

Português:

O atributo maskUnits indica qual sistema de coordenadas usar para as propriedades geométricas do elemento <mask>. 

Entrada:
  value: especifica o sistema de coordenadas
    const KSvgUnits... (e.g. KSvgUnitsObjectBoundingBox)
    qualquer outro tipo: interface{}

func (*TagSvgMask) Opacity 

func (e *TagSvgMask) Opacity(value interface{}) (ref *TagSvgMask)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgMask) Overflow 

func (e *TagSvgMask) Overflow(value interface{}) (ref *TagSvgMask)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgMask) PointerEvents 

func (e *TagSvgMask) PointerEvents(value interface{}) (ref *TagSvgMask)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgMask) ShapeRendering 

func (e *TagSvgMask) ShapeRendering(value interface{}) (ref *TagSvgMask)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgMask) StopColor 

func (e *TagSvgMask) StopColor(value interface{}) (ref *TagSvgMask)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgMask) StopOpacity 

func (e *TagSvgMask) StopOpacity(value interface{}) (ref *TagSvgMask)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgMask) Stroke 

func (e *TagSvgMask) Stroke(value interface{}) (ref *TagSvgMask)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgMask) StrokeDasharray 

func (e *TagSvgMask) StrokeDasharray(value interface{}) (ref *TagSvgMask)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgMask) StrokeLineCap 

func (e *TagSvgMask) StrokeLineCap(value interface{}) (ref *TagSvgMask)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgMask) StrokeLineJoin 

func (e *TagSvgMask) StrokeLineJoin(value interface{}) (ref *TagSvgMask)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgMask) StrokeMiterLimit 

func (e *TagSvgMask) StrokeMiterLimit(value float64) (ref *TagSvgMask)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgMask) StrokeOpacity 

func (e *TagSvgMask) StrokeOpacity(value interface{}) (ref *TagSvgMask)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgMask) StrokeWidth 

func (e *TagSvgMask) StrokeWidth(value interface{}) (ref *TagSvgMask)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgMask) Style 

func (e *TagSvgMask) Style(value string) (ref *TagSvgMask)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgMask) Tabindex 

func (e *TagSvgMask) Tabindex(value int) (ref *TagSvgMask)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgMask) Text 

func (e *TagSvgMask) Text(value string) (ref *TagSvgMask)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgMask) TextAnchor 

func (e *TagSvgMask) TextAnchor(value interface{}) (ref *TagSvgMask)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgMask) TextDecoration 

func (e *TagSvgMask) TextDecoration(value interface{}) (ref *TagSvgMask)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgMask) TextRendering 

func (e *TagSvgMask) TextRendering(value interface{}) (ref *TagSvgMask)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgMask) Transform 

func (e *TagSvgMask) Transform(value interface{}) (ref *TagSvgMask)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgMask) UnicodeBidi 

func (e *TagSvgMask) UnicodeBidi(value interface{}) (ref *TagSvgMask)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgMask) VectorEffect 

func (e *TagSvgMask) VectorEffect(value interface{}) (ref *TagSvgMask)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgMask) Visibility 

func (e *TagSvgMask) Visibility(value interface{}) (ref *TagSvgMask)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgMask) Width 

func (e *TagSvgMask) Width(value interface{}) (ref *TagSvgMask)

Width

English:

The width attribute defines the horizontal length of an element in the user coordinate system. 

Input:
  value: the horizontal length of an element
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo largura define o comprimento horizontal de um elemento no sistema de coordenadas do usuário. 

Entrada:
  value: o comprimento horizontal de um elemento
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgMask) WordSpacing 

func (e *TagSvgMask) WordSpacing(value interface{}) (ref *TagSvgMask)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgMask) WritingMode 

func (e *TagSvgMask) WritingMode(value interface{}) (ref *TagSvgMask)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgMask) X 

func (e *TagSvgMask) X(value interface{}) (ref *TagSvgMask)

X

English:

The x attribute defines an x-axis coordinate in the user coordinate system. 

Input:
  value: defines an x-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo x define uma coordenada do eixo x no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo x
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgMask) XmlLang 

func (e *TagSvgMask) XmlLang(value interface{}) (ref *TagSvgMask)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

func (*TagSvgMask) Y 

func (e *TagSvgMask) Y(value interface{}) (ref *TagSvgMask)

Y

English:

The y attribute defines an y-axis coordinate in the user coordinate system. 

Input:
  value: defines an y-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo y define uma coordenada do eixo y no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo y
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

type TagSvgMetadata 

type TagSvgMetadata struct {
	// contains filtered or unexported fields
}

TagSvgMetadata

English:

The <metadata> SVG element adds metadata to SVG content. Metadata is structured information about data. The contents of <metadata> should be elements from other XML namespaces such as RDF, FOAF, etc.

Português:

O elemento SVG <metadata> adiciona metadados ao conteúdo SVG. Metadados são informações estruturadas sobre dados. O conteúdo de <metadata> deve ser elementos de outros namespaces XML, como RDF, FOAF, etc.

func (*TagSvgMetadata) Append 

func (e *TagSvgMetadata) Append(elements ...Compatible) (ref *TagSvgMetadata)

func (*TagSvgMetadata) AppendById 

func (e *TagSvgMetadata) AppendById(appendId string) (ref *TagSvgMetadata)

func (*TagSvgMetadata) AppendToElement 

func (e *TagSvgMetadata) AppendToElement(el js.Value) (ref *TagSvgMetadata)

func (*TagSvgMetadata) AppendToStage 

func (e *TagSvgMetadata) AppendToStage() (ref *TagSvgMetadata)

func (*TagSvgMetadata) CreateElement 

func (e *TagSvgMetadata) CreateElement() (ref *TagSvgMetadata)

func (*TagSvgMetadata) Get 

func (e *TagSvgMetadata) Get() (el js.Value)

func (*TagSvgMetadata) Html 

func (e *TagSvgMetadata) Html(value string) (ref *TagSvgMetadata)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgMetadata) Id 

func (e *TagSvgMetadata) Id(id string) (ref *TagSvgMetadata)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgMetadata) Init 

func (e *TagSvgMetadata) Init() (ref *TagSvgMetadata)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgMetadata) Lang 

func (e *TagSvgMetadata) Lang(value interface{}) (ref *TagSvgMetadata)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgMetadata) Tabindex 

func (e *TagSvgMetadata) Tabindex(value int) (ref *TagSvgMetadata)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgMetadata) Text 

func (e *TagSvgMetadata) Text(value string) (ref *TagSvgMetadata)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgMetadata) XmlLang 

func (e *TagSvgMetadata) XmlLang(value interface{}) (ref *TagSvgMetadata)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

type TagSvgPath 

type TagSvgPath struct {
	// contains filtered or unexported fields
}

TagSvgPath

English:

The <path> SVG element is the generic element to define a shape. All the basic shapes can be created with a path element.

Português:

O elemento SVG <path> é o elemento genérico para definir uma forma. Todas as formas básicas podem ser criadas com um elemento de caminho.

func (*TagSvgPath) Append 

func (e *TagSvgPath) Append(elements ...Compatible) (ref *TagSvgPath)

func (*TagSvgPath) AppendById 

func (e *TagSvgPath) AppendById(appendId string) (ref *TagSvgPath)

func (*TagSvgPath) AppendToElement 

func (e *TagSvgPath) AppendToElement(el js.Value) (ref *TagSvgPath)

func (*TagSvgPath) AppendToStage 

func (e *TagSvgPath) AppendToStage() (ref *TagSvgPath)

func (*TagSvgPath) BaselineShift 

func (e *TagSvgPath) BaselineShift(baselineShift interface{}) (ref *TagSvgPath)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgPath) Class 

func (e *TagSvgPath) Class(class string) (ref *TagSvgPath)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgPath) ClipPath 

func (e *TagSvgPath) ClipPath(clipPath string) (ref *TagSvgPath)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgPath) ClipRule 

func (e *TagSvgPath) ClipRule(value interface{}) (ref *TagSvgPath)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgPath) Color 

func (e *TagSvgPath) Color(value interface{}) (ref *TagSvgPath)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgPath) ColorInterpolation 

func (e *TagSvgPath) ColorInterpolation(value interface{}) (ref *TagSvgPath)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgPath) ColorInterpolationFilters 

func (e *TagSvgPath) ColorInterpolationFilters(value interface{}) (ref *TagSvgPath)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgPath) CreateElement 

func (e *TagSvgPath) CreateElement() (ref *TagSvgPath)

func (*TagSvgPath) Cursor 

func (e *TagSvgPath) Cursor(cursor SvgCursor) (ref *TagSvgPath)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgPath) D 

func (e *TagSvgPath) D(d interface{}) (ref *TagSvgPath)

D

English: 

The d attribute defines a path to be drawn.

 d: path to be drawn
   *SvgPath: factoryBrowser.NewPath().M(0, 10).Hd(5).Vd(-9).Hd(12).Vd(9).Hd(5).Vd(16).Hd(-22).Z()
   any other type: interface{}

A path definition is a list of path commands where each command is composed of a command letter and numbers that represent the command parameters. The commands are detailed below.

You can use this attribute with the following SVG elements: <path>, <glyph>, <missing-glyph>.

d is a presentation attribute, and hence can also be used as a CSS property.

Português: 

O atributo d define um caminho a ser desenhado.

 d: caminho a ser desenhado
   *SvgPath: factoryBrowser.NewPath().M(0, 10).Hd(5).Vd(-9).Hd(12).Vd(9).Hd(5).Vd(16).Hd(-22).Z()
   qualquer outro tipo: interface{}

Uma definição de caminho é uma lista de comandos de caminho em que cada comando é composto por uma letra de comando e números que representam os parâmetros do comando. Os comandos são detalhados abaixo.

Você pode usar este atributo com os seguintes elementos SVG: <path>, <glyph>, <missing-glyph>.

d é um atributo de apresentação e, portanto, também pode ser usado como uma propriedade CSS.

func (*TagSvgPath) Direction 

func (e *TagSvgPath) Direction(direction SvgDirection) (ref *TagSvgPath)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgPath) Display 

func (e *TagSvgPath) Display(value interface{}) (ref *TagSvgPath)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgPath) DominantBaseline 

func (e *TagSvgPath) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgPath)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgPath) Fill 

func (e *TagSvgPath) Fill(value interface{}) (ref *TagSvgPath)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgPath) FillOpacity 

func (e *TagSvgPath) FillOpacity(value interface{}) (ref *TagSvgPath)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgPath) FillRule 

func (e *TagSvgPath) FillRule(fillRule SvgFillRule) (ref *TagSvgPath)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgPath) Filter 

func (e *TagSvgPath) Filter(filter string) (ref *TagSvgPath)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgPath) FloodColor 

func (e *TagSvgPath) FloodColor(floodColor interface{}) (ref *TagSvgPath)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgPath) FloodOpacity 

func (e *TagSvgPath) FloodOpacity(floodOpacity float64) (ref *TagSvgPath)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgPath) FontFamily 

func (e *TagSvgPath) FontFamily(fontFamily string) (ref *TagSvgPath)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgPath) FontSize 

func (e *TagSvgPath) FontSize(fontSize interface{}) (ref *TagSvgPath)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgPath) FontSizeAdjust 

func (e *TagSvgPath) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgPath)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgPath) FontStretch 

func (e *TagSvgPath) FontStretch(fontStretch interface{}) (ref *TagSvgPath)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgPath) FontStyle 

func (e *TagSvgPath) FontStyle(fontStyle FontStyleRule) (ref *TagSvgPath)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgPath) FontVariant 

func (e *TagSvgPath) FontVariant(value interface{}) (ref *TagSvgPath)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgPath) FontWeight 

func (e *TagSvgPath) FontWeight(value interface{}) (ref *TagSvgPath)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgPath) Get 

func (e *TagSvgPath) Get() (el js.Value)

func (*TagSvgPath) Html 

func (e *TagSvgPath) Html(value string) (ref *TagSvgPath)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgPath) Id 

func (e *TagSvgPath) Id(id string) (ref *TagSvgPath)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgPath) ImageRendering 

func (e *TagSvgPath) ImageRendering(imageRendering string) (ref *TagSvgPath)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgPath) Init 

func (e *TagSvgPath) Init() (ref *TagSvgPath)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgPath) Lang 

func (e *TagSvgPath) Lang(value interface{}) (ref *TagSvgPath)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgPath) LetterSpacing 

func (e *TagSvgPath) LetterSpacing(value float64) (ref *TagSvgPath)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgPath) LightingColor 

func (e *TagSvgPath) LightingColor(value interface{}) (ref *TagSvgPath)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgPath) MarkerEnd 

func (e *TagSvgPath) MarkerEnd(value interface{}) (ref *TagSvgPath)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgPath) MarkerMid 

func (e *TagSvgPath) MarkerMid(value interface{}) (ref *TagSvgPath)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgPath) MarkerStart 

func (e *TagSvgPath) MarkerStart(value interface{}) (ref *TagSvgPath)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgPath) Mask 

func (e *TagSvgPath) Mask(value interface{}) (ref *TagSvgPath)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgPath) Opacity 

func (e *TagSvgPath) Opacity(value interface{}) (ref *TagSvgPath)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgPath) Overflow 

func (e *TagSvgPath) Overflow(value interface{}) (ref *TagSvgPath)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgPath) PaintOrder 

func (e *TagSvgPath) PaintOrder(value interface{}) (ref *TagSvgPath)

PaintOrder

English:

The paint-order attribute specifies the order that the fill, stroke, and markers of a given shape or text element are painted. 

Input:
  value: specifies the order that the fill, stroke, and markers
    const: SvgPaintOrder... (e.g. KSvgPaintOrderStroke)
    any other type: interface{}

Notes:
  * As a presentation attribute, paint-order can be used as a CSS property.

Português:

O atributo paint-order especifica a ordem em que o preenchimento, o traçado e os marcadores de uma determinada forma ou elemento de texto são pintados. 

Entrada:
  value: especifica a ordem em que o preenchimento, o traçado e os marcadores
    const: SvgPaintOrder... (e.g. KSvgPaintOrderStroke)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, paint-order pode ser usado como uma propriedade CSS.

func (*TagSvgPath) PathLength 

func (e *TagSvgPath) PathLength(value interface{}) (ref *TagSvgPath)

PathLength

English:

The pathLength attribute lets authors specify a total length for the path, in user units. This value is then used to calibrate the browser's distance calculations with those of the author, by scaling all distance computations using the ratio pathLength/(computed value of path length).

This can affect the actual rendered lengths of paths; including text paths, animation paths, and various stroke operations. Basically, all computations that require the length of the path. stroke-dasharray, for example, will assume the start of the path being 0 and the end point the value defined in the pathLength attribute.

Português:

O atributo pathLength permite que os autores especifiquem um comprimento total para o caminho, em unidades de usuário. Este valor é então usado para calibrar os cálculos de distância do navegador com os do autor, escalando todos os cálculos de distância usando a razão pathLength (valor calculado do comprimento do caminho).

Isso pode afetar os comprimentos reais dos caminhos renderizados; incluindo caminhos de texto, caminhos de animação e várias operações de traçado. Basicamente, todos os cálculos que exigem o comprimento do caminho. stroke-dasharray, por exemplo, assumirá o início do caminho sendo 0 e o ponto final o valor definido no atributo pathLength.

func (*TagSvgPath) PointerEvents 

func (e *TagSvgPath) PointerEvents(value interface{}) (ref *TagSvgPath)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgPath) ShapeRendering 

func (e *TagSvgPath) ShapeRendering(value interface{}) (ref *TagSvgPath)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgPath) StopColor 

func (e *TagSvgPath) StopColor(value interface{}) (ref *TagSvgPath)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgPath) StopOpacity 

func (e *TagSvgPath) StopOpacity(value interface{}) (ref *TagSvgPath)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgPath) Stroke 

func (e *TagSvgPath) Stroke(value interface{}) (ref *TagSvgPath)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgPath) StrokeDashOffset 

func (e *TagSvgPath) StrokeDashOffset(value interface{}) (ref *TagSvgPath)

StrokeDashOffset

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    float32: 0.1 = "10%"
    []float32: (e.g. []float32{0.04, 0.01, 0.02}) = "4% 1% 2%"
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    float32: 0.1 = "10%"
    []float32: (e.g. []float32{0.04, 0.01, 0.02}) = "4% 1% 2%"
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgPath) StrokeDasharray 

func (e *TagSvgPath) StrokeDasharray(value interface{}) (ref *TagSvgPath)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgPath) StrokeLineCap 

func (e *TagSvgPath) StrokeLineCap(value interface{}) (ref *TagSvgPath)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgPath) StrokeLineJoin 

func (e *TagSvgPath) StrokeLineJoin(value interface{}) (ref *TagSvgPath)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgPath) StrokeMiterLimit 

func (e *TagSvgPath) StrokeMiterLimit(value float64) (ref *TagSvgPath)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgPath) StrokeOpacity 

func (e *TagSvgPath) StrokeOpacity(value interface{}) (ref *TagSvgPath)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgPath) StrokeWidth 

func (e *TagSvgPath) StrokeWidth(value interface{}) (ref *TagSvgPath)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgPath) Style 

func (e *TagSvgPath) Style(value string) (ref *TagSvgPath)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgPath) Tabindex 

func (e *TagSvgPath) Tabindex(value int) (ref *TagSvgPath)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgPath) Text 

func (e *TagSvgPath) Text(value string) (ref *TagSvgPath)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgPath) TextAnchor 

func (e *TagSvgPath) TextAnchor(value interface{}) (ref *TagSvgPath)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgPath) TextDecoration 

func (e *TagSvgPath) TextDecoration(value interface{}) (ref *TagSvgPath)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgPath) TextRendering 

func (e *TagSvgPath) TextRendering(value interface{}) (ref *TagSvgPath)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgPath) Transform 

func (e *TagSvgPath) Transform(value interface{}) (ref *TagSvgPath)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgPath) UnicodeBidi 

func (e *TagSvgPath) UnicodeBidi(value interface{}) (ref *TagSvgPath)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgPath) VectorEffect 

func (e *TagSvgPath) VectorEffect(value interface{}) (ref *TagSvgPath)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgPath) Visibility 

func (e *TagSvgPath) Visibility(value interface{}) (ref *TagSvgPath)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgPath) WordSpacing 

func (e *TagSvgPath) WordSpacing(value interface{}) (ref *TagSvgPath)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgPath) WritingMode 

func (e *TagSvgPath) WritingMode(value interface{}) (ref *TagSvgPath)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgPath) XmlLang 

func (e *TagSvgPath) XmlLang(value interface{}) (ref *TagSvgPath)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

type TagSvgPattern 

type TagSvgPattern struct {
	// contains filtered or unexported fields
}

TagSvgPattern

English:

The <pattern> element defines a graphics object which can be redrawn at repeated x- and y-coordinate intervals ("tiled") to cover an area.

The <pattern> is referenced by the fill and/or stroke attributes on other graphics elements to fill or stroke those elements with the referenced pattern.

Português:

O elemento <pattern> define um objeto gráfico que pode ser redesenhado em intervalos repetidos de coordenadas x e y ("lado a lado") para cobrir uma área.

O <pattern> é referenciado pelos atributos fill andor stroke em outros elementos gráficos para preencher ou traçar esses elementos com o padrão referenciado.

func (*TagSvgPattern) Append 

func (e *TagSvgPattern) Append(elements ...Compatible) (ref *TagSvgPattern)

func (*TagSvgPattern) AppendById 

func (e *TagSvgPattern) AppendById(appendId string) (ref *TagSvgPattern)

func (*TagSvgPattern) AppendToElement 

func (e *TagSvgPattern) AppendToElement(el js.Value) (ref *TagSvgPattern)

func (*TagSvgPattern) AppendToStage 

func (e *TagSvgPattern) AppendToStage() (ref *TagSvgPattern)

func (*TagSvgPattern) BaselineShift 

func (e *TagSvgPattern) BaselineShift(baselineShift interface{}) (ref *TagSvgPattern)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgPattern) Class 

func (e *TagSvgPattern) Class(class string) (ref *TagSvgPattern)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgPattern) ClipPath 

func (e *TagSvgPattern) ClipPath(clipPath string) (ref *TagSvgPattern)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgPattern) ClipRule 

func (e *TagSvgPattern) ClipRule(value interface{}) (ref *TagSvgPattern)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgPattern) Color 

func (e *TagSvgPattern) Color(value interface{}) (ref *TagSvgPattern)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgPattern) ColorInterpolation 

func (e *TagSvgPattern) ColorInterpolation(value interface{}) (ref *TagSvgPattern)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgPattern) ColorInterpolationFilters 

func (e *TagSvgPattern) ColorInterpolationFilters(value interface{}) (ref *TagSvgPattern)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgPattern) CreateElement 

func (e *TagSvgPattern) CreateElement() (ref *TagSvgPattern)

func (*TagSvgPattern) Cursor 

func (e *TagSvgPattern) Cursor(cursor SvgCursor) (ref *TagSvgPattern)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgPattern) Direction 

func (e *TagSvgPattern) Direction(direction SvgDirection) (ref *TagSvgPattern)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgPattern) Display 

func (e *TagSvgPattern) Display(value interface{}) (ref *TagSvgPattern)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgPattern) DominantBaseline 

func (e *TagSvgPattern) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgPattern)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgPattern) Fill 

func (e *TagSvgPattern) Fill(value interface{}) (ref *TagSvgPattern)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgPattern) FillOpacity 

func (e *TagSvgPattern) FillOpacity(value interface{}) (ref *TagSvgPattern)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgPattern) FillRule 

func (e *TagSvgPattern) FillRule(fillRule SvgFillRule) (ref *TagSvgPattern)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgPattern) Filter 

func (e *TagSvgPattern) Filter(filter string) (ref *TagSvgPattern)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgPattern) FloodColor 

func (e *TagSvgPattern) FloodColor(floodColor interface{}) (ref *TagSvgPattern)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgPattern) FloodOpacity 

func (e *TagSvgPattern) FloodOpacity(floodOpacity float64) (ref *TagSvgPattern)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgPattern) FontFamily 

func (e *TagSvgPattern) FontFamily(fontFamily string) (ref *TagSvgPattern)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgPattern) FontSize 

func (e *TagSvgPattern) FontSize(fontSize interface{}) (ref *TagSvgPattern)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgPattern) FontSizeAdjust 

func (e *TagSvgPattern) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgPattern)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgPattern) FontStretch 

func (e *TagSvgPattern) FontStretch(fontStretch interface{}) (ref *TagSvgPattern)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgPattern) FontStyle 

func (e *TagSvgPattern) FontStyle(fontStyle FontStyleRule) (ref *TagSvgPattern)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgPattern) FontVariant 

func (e *TagSvgPattern) FontVariant(value interface{}) (ref *TagSvgPattern)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgPattern) FontWeight 

func (e *TagSvgPattern) FontWeight(value interface{}) (ref *TagSvgPattern)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgPattern) Get 

func (e *TagSvgPattern) Get() (el js.Value)

func (*TagSvgPattern) HRef 

func (e *TagSvgPattern) HRef(href string) (ref *TagSvgPattern)

HRef

English: 

The href attribute defines a link to a resource as a reference URL. The exact meaning of that link depends on the
context of each element using it.

 Notes:
   * Specifications before SVG 2 defined an xlink:href attribute, which is now rendered obsolete by the href
     attribute.
     If you need to support earlier browser versions, the deprecated xlink:href attribute can be used as a fallback
     in addition to the href attribute, e.g. <use href="some-id" xlink:href="some-id x="5" y="5" />.

Português: 

O atributo href define um link para um recurso como um URL de referência. O significado exato desse link depende do
contexto de cada elemento que o utiliza.

 Notas:
   * As especificações anteriores ao SVG 2 definiam um atributo xlink:href, que agora se torna obsoleto pelo
     atributo href.
     Se você precisar oferecer suporte a versões anteriores do navegador, o atributo obsoleto xlink:href pode ser
     usado como um substituto além do atributo href, por exemplo,
     <use href="some-id" xlink:href="some-id x="5" y="5" />.

func (*TagSvgPattern) Height 

func (e *TagSvgPattern) Height(height interface{}) (ref *TagSvgPattern)

Height

English: 

The height attribute defines the vertical length of an element in the user coordinate system.
     float32: 1.0 = "100%"
     any other type: interface{}

Português: 

O atributo height define o comprimento vertical de um elemento no sistema de coordenadas do usuário.
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

func (*TagSvgPattern) Html 

func (e *TagSvgPattern) Html(value string) (ref *TagSvgPattern)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgPattern) Id 

func (e *TagSvgPattern) Id(id string) (ref *TagSvgPattern)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgPattern) ImageRendering 

func (e *TagSvgPattern) ImageRendering(imageRendering string) (ref *TagSvgPattern)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgPattern) Init 

func (e *TagSvgPattern) Init() (ref *TagSvgPattern)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgPattern) Lang 

func (e *TagSvgPattern) Lang(value interface{}) (ref *TagSvgPattern)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgPattern) LetterSpacing 

func (e *TagSvgPattern) LetterSpacing(value float64) (ref *TagSvgPattern)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgPattern) LightingColor 

func (e *TagSvgPattern) LightingColor(value interface{}) (ref *TagSvgPattern)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgPattern) MarkerEnd 

func (e *TagSvgPattern) MarkerEnd(value interface{}) (ref *TagSvgPattern)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgPattern) MarkerMid 

func (e *TagSvgPattern) MarkerMid(value interface{}) (ref *TagSvgPattern)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgPattern) MarkerStart 

func (e *TagSvgPattern) MarkerStart(value interface{}) (ref *TagSvgPattern)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgPattern) Mask 

func (e *TagSvgPattern) Mask(value interface{}) (ref *TagSvgPattern)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgPattern) Opacity 

func (e *TagSvgPattern) Opacity(value interface{}) (ref *TagSvgPattern)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgPattern) Overflow 

func (e *TagSvgPattern) Overflow(value interface{}) (ref *TagSvgPattern)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgPattern) PatternContentUnits 

func (e *TagSvgPattern) PatternContentUnits(value interface{}) (ref *TagSvgPattern)

PatternContentUnits

English:

The patternContentUnits attribute indicates which coordinate system to use for the contents of the <pattern> element. 

Input:
  value: specifies the coordinate system
    const KSvgUnits... (e.g. KSvgUnitsObjectBoundingBox)
    any other type: interface{}

Notes:
  * That this attribute has no effect if attribute viewBox is specified on the <pattern> element.

Português:

O atributo patternContentUnits indica qual sistema de coordenadas deve ser usado para o conteúdo do elemento <pattern>. 

Entrada:
  value: especifica o sistema de coordenadas
    const KSvgUnits... (e.g. KSvgUnitsObjectBoundingBox)
    qualquer outro tipo: interface{}

Notas:
  * Que este atributo não tem efeito se o atributo viewBox for especificado no elemento <pattern>.

func (*TagSvgPattern) PatternTransform 

func (e *TagSvgPattern) PatternTransform(value interface{}) (ref *TagSvgPattern)

PatternTransform

English:

The patternTransform attribute defines a list of transform definitions that are applied to a pattern tile.

Português:

O atributo patternTransform define uma lista de definições de transformação que são aplicadas a um bloco de padrão.

func (*TagSvgPattern) PatternUnits 

func (e *TagSvgPattern) PatternUnits(value interface{}) (ref *TagSvgPattern)

PatternUnits

English:

The patternUnits attribute indicates which coordinate system to use for the geometry properties of the <pattern> element. 

Input:
  value: specifies the coordinate system
    const KSvgUnits... (e.g. KSvgUnitsObjectBoundingBox)
    any other type: interface{}

Português:

O atributo patternUnits indica qual sistema de coordenadas deve ser usado para as propriedades geométricas do elemento <pattern>. 

Entrada:
  value: especifica o sistema de coordenadas
    const KSvgUnits... (e.g. KSvgUnitsObjectBoundingBox)
    qualquer outro tipo: interface{}

func (*TagSvgPattern) PointerEvents 

func (e *TagSvgPattern) PointerEvents(value interface{}) (ref *TagSvgPattern)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgPattern) PreserveAspectRatio 

func (e *TagSvgPattern) PreserveAspectRatio(ratio, meet interface{}) (ref *TagSvgPattern)

PreserveAspectRatio

English: 

The preserveAspectRatio attribute indicates how an element with a viewBox providing a given aspect ratio must fit
into a viewport with a different aspect ratio.

 Input:
   ratio: Indicates how an element with a viewBox providing a given aspect ratio.
     const: KRatio... (e.g. KRatioXMinYMin)
     any other type: interface{}
   meet: The meet or slice reference
     const: KMeetOrSliceReference... (e.g. KMeetOrSliceReferenceSlice)
     any other type: interface{}

Because the aspect ratio of an SVG image is defined by the viewBox attribute, if this attribute isn't set, the preserveAspectRatio attribute has no effect (with one exception, the <image> element, as described below).

Português: 

O atributo preserveAspectRatio indica como um elemento com uma viewBox fornecendo uma determinada proporção deve
caber em uma viewport com uma proporção diferente.

 Input:
   ratio: Indica como um elemento com uma viewBox fornece uma determinada proporção.
     const: KRatio... (ex. KRatioXMinYMin)
     qualquer outro tipo: interface{}
   meet: A referência de encontro ou fatia
     const: KMeetOrSliceReference... (ex. KMeetOrSliceReferenceSlice)
     qualquer outro tipo: interface{}

Como a proporção de uma imagem SVG é definida pelo atributo viewBox, se esse atributo não estiver definido, o atributo preserveAspectRatio não terá efeito (com uma exceção, o elemento <image>, conforme descrito abaixo).

func (*TagSvgPattern) ShapeRendering 

func (e *TagSvgPattern) ShapeRendering(value interface{}) (ref *TagSvgPattern)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgPattern) StopColor 

func (e *TagSvgPattern) StopColor(value interface{}) (ref *TagSvgPattern)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgPattern) StopOpacity 

func (e *TagSvgPattern) StopOpacity(value interface{}) (ref *TagSvgPattern)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgPattern) Stroke 

func (e *TagSvgPattern) Stroke(value interface{}) (ref *TagSvgPattern)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgPattern) StrokeDasharray 

func (e *TagSvgPattern) StrokeDasharray(value interface{}) (ref *TagSvgPattern)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgPattern) StrokeLineCap 

func (e *TagSvgPattern) StrokeLineCap(value interface{}) (ref *TagSvgPattern)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgPattern) StrokeLineJoin 

func (e *TagSvgPattern) StrokeLineJoin(value interface{}) (ref *TagSvgPattern)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgPattern) StrokeMiterLimit 

func (e *TagSvgPattern) StrokeMiterLimit(value float64) (ref *TagSvgPattern)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgPattern) StrokeOpacity 

func (e *TagSvgPattern) StrokeOpacity(value interface{}) (ref *TagSvgPattern)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgPattern) StrokeWidth 

func (e *TagSvgPattern) StrokeWidth(value interface{}) (ref *TagSvgPattern)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgPattern) Style 

func (e *TagSvgPattern) Style(value string) (ref *TagSvgPattern)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgPattern) Tabindex 

func (e *TagSvgPattern) Tabindex(value int) (ref *TagSvgPattern)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgPattern) Text 

func (e *TagSvgPattern) Text(value string) (ref *TagSvgPattern)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgPattern) TextAnchor 

func (e *TagSvgPattern) TextAnchor(value interface{}) (ref *TagSvgPattern)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgPattern) TextDecoration 

func (e *TagSvgPattern) TextDecoration(value interface{}) (ref *TagSvgPattern)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgPattern) TextRendering 

func (e *TagSvgPattern) TextRendering(value interface{}) (ref *TagSvgPattern)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgPattern) Transform 

func (e *TagSvgPattern) Transform(value interface{}) (ref *TagSvgPattern)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgPattern) UnicodeBidi 

func (e *TagSvgPattern) UnicodeBidi(value interface{}) (ref *TagSvgPattern)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgPattern) VectorEffect 

func (e *TagSvgPattern) VectorEffect(value interface{}) (ref *TagSvgPattern)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgPattern) ViewBox 

func (e *TagSvgPattern) ViewBox(value interface{}) (ref *TagSvgPattern)

ViewBox

English:

The viewBox attribute defines the position and dimension, in user space, of an SVG viewport. 

Input:
  value: defines the position and dimension, in user space, of an SVG viewport
    []float64: ex. []float64{0.0, 0.0, 10.0, 10.0} = "0 0 10 10"
    any other type: interface{}

The value of the viewBox attribute is a list of four numbers: min-x, min-y, width and height. The numbers, which are separated by whitespace and/or a comma, specify a rectangle in user space which is mapped to the bounds of the viewport established for the associated SVG element (not the browser viewport).

Português:

O atributo viewBox define a posição e a dimensão, no espaço do usuário, de uma viewport SVG. 

Input:
  value: define a posição e dimensão, no espaço do usuário, de uma viewport SVG
    []float64: ex. []float64{0.0, 0.0, 10.0, 10.0} = "0 0 10 10"
    qualquer outro tipo: interface{}

O valor do atributo viewBox é uma lista de quatro números: min-x, min-y, largura e altura. Os números, que são separados por espaço em branco e ou vírgula, especificam um retângulo no espaço do usuário que é mapeado para os limites da janela de visualização estabelecida para o elemento SVG associado (não a janela de visualização do navegador).

func (*TagSvgPattern) Visibility 

func (e *TagSvgPattern) Visibility(value interface{}) (ref *TagSvgPattern)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgPattern) Width 

func (e *TagSvgPattern) Width(value interface{}) (ref *TagSvgPattern)

Width

English:

The width attribute defines the horizontal length of an element in the user coordinate system. 

Input:
  value: the horizontal length of an element
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo largura define o comprimento horizontal de um elemento no sistema de coordenadas do usuário. 

Entrada:
  value: o comprimento horizontal de um elemento
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgPattern) WordSpacing 

func (e *TagSvgPattern) WordSpacing(value interface{}) (ref *TagSvgPattern)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgPattern) WritingMode 

func (e *TagSvgPattern) WritingMode(value interface{}) (ref *TagSvgPattern)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgPattern) X 

func (e *TagSvgPattern) X(value interface{}) (ref *TagSvgPattern)

X

English:

The x attribute defines an x-axis coordinate in the user coordinate system. 

Input:
  value: defines an x-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo x define uma coordenada do eixo x no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo x
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgPattern) XLinkHRef deprecated 

func (e *TagSvgPattern) XLinkHRef(value interface{}) (ref *TagSvgPattern)

XLinkHRef

English:

Deprecated: use HRef() function

The xlink:href attribute defines a reference to a resource as a reference IRI. The exact meaning of that link depends on the context of each element using it. 

Notes:
  * SVG 2 removed the need for the xlink namespace, so instead of xlink:href you should use href. If you need to
    support earlier browser versions, the deprecated xlink:href attribute can be used as a fallback in addition to
    the href attribute, e.g. <use href="some-id" xlink:href="some-id" x="5" y="5" />.

Português:

Obsoleto: use a função HRef()

O atributo xlink:href define uma referência a um recurso como um IRI de referência. O significado exato desse link depende do contexto de cada elemento que o utiliza. 

Notas:
  * O SVG 2 removeu a necessidade do namespace xlink, então ao invés de xlink:href você deve usar href. Se você
    precisar oferecer suporte a versões anteriores do navegador, o atributo obsoleto xlink:href pode ser usado como
    um substituto além do atributo href, por exemplo, <use href="some-id" xlink:href="some-id" x="5" y="5" >.

func (*TagSvgPattern) XmlLang 

func (e *TagSvgPattern) XmlLang(value interface{}) (ref *TagSvgPattern)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

func (*TagSvgPattern) Y 

func (e *TagSvgPattern) Y(value interface{}) (ref *TagSvgPattern)

Y

English:

The y attribute defines an y-axis coordinate in the user coordinate system. 

Input:
  value: defines an y-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo y define uma coordenada do eixo y no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo y
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

type TagSvgPolygon 

type TagSvgPolygon struct {
	// contains filtered or unexported fields
}

TagSvgPolygon

English:

The <polygon> element defines a closed shape consisting of a set of connected straight line segments. The last point is connected to the first point.

For open shapes, see the <polyline> element.

Português:

O elemento <polygon> define uma forma fechada que consiste em um conjunto de segmentos de linha reta conectados. O último ponto está conectado ao primeiro ponto.

Para formas abertas, consulte o elemento <polyline>.

func (*TagSvgPolygon) Append 

func (e *TagSvgPolygon) Append(elements ...Compatible) (ref *TagSvgPolygon)

func (*TagSvgPolygon) AppendById 

func (e *TagSvgPolygon) AppendById(appendId string) (ref *TagSvgPolygon)

func (*TagSvgPolygon) AppendToElement 

func (e *TagSvgPolygon) AppendToElement(el js.Value) (ref *TagSvgPolygon)

func (*TagSvgPolygon) AppendToStage 

func (e *TagSvgPolygon) AppendToStage() (ref *TagSvgPolygon)

func (*TagSvgPolygon) BaselineShift 

func (e *TagSvgPolygon) BaselineShift(baselineShift interface{}) (ref *TagSvgPolygon)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgPolygon) Class 

func (e *TagSvgPolygon) Class(class string) (ref *TagSvgPolygon)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgPolygon) ClipPath 

func (e *TagSvgPolygon) ClipPath(clipPath string) (ref *TagSvgPolygon)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgPolygon) ClipRule 

func (e *TagSvgPolygon) ClipRule(value interface{}) (ref *TagSvgPolygon)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgPolygon) Color 

func (e *TagSvgPolygon) Color(value interface{}) (ref *TagSvgPolygon)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgPolygon) ColorInterpolation 

func (e *TagSvgPolygon) ColorInterpolation(value interface{}) (ref *TagSvgPolygon)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgPolygon) ColorInterpolationFilters 

func (e *TagSvgPolygon) ColorInterpolationFilters(value interface{}) (ref *TagSvgPolygon)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgPolygon) CreateElement 

func (e *TagSvgPolygon) CreateElement() (ref *TagSvgPolygon)

func (*TagSvgPolygon) Cursor 

func (e *TagSvgPolygon) Cursor(cursor SvgCursor) (ref *TagSvgPolygon)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgPolygon) Direction 

func (e *TagSvgPolygon) Direction(direction SvgDirection) (ref *TagSvgPolygon)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgPolygon) Display 

func (e *TagSvgPolygon) Display(value interface{}) (ref *TagSvgPolygon)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgPolygon) DominantBaseline 

func (e *TagSvgPolygon) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgPolygon)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgPolygon) Fill 

func (e *TagSvgPolygon) Fill(value interface{}) (ref *TagSvgPolygon)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgPolygon) FillOpacity 

func (e *TagSvgPolygon) FillOpacity(value interface{}) (ref *TagSvgPolygon)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgPolygon) FillRule 

func (e *TagSvgPolygon) FillRule(fillRule SvgFillRule) (ref *TagSvgPolygon)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgPolygon) Filter 

func (e *TagSvgPolygon) Filter(filter string) (ref *TagSvgPolygon)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgPolygon) FloodColor 

func (e *TagSvgPolygon) FloodColor(floodColor interface{}) (ref *TagSvgPolygon)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgPolygon) FloodOpacity 

func (e *TagSvgPolygon) FloodOpacity(floodOpacity float64) (ref *TagSvgPolygon)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgPolygon) FontFamily 

func (e *TagSvgPolygon) FontFamily(fontFamily string) (ref *TagSvgPolygon)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgPolygon) FontSize 

func (e *TagSvgPolygon) FontSize(fontSize interface{}) (ref *TagSvgPolygon)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgPolygon) FontSizeAdjust 

func (e *TagSvgPolygon) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgPolygon)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgPolygon) FontStretch 

func (e *TagSvgPolygon) FontStretch(fontStretch interface{}) (ref *TagSvgPolygon)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgPolygon) FontStyle 

func (e *TagSvgPolygon) FontStyle(fontStyle FontStyleRule) (ref *TagSvgPolygon)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgPolygon) FontVariant 

func (e *TagSvgPolygon) FontVariant(value interface{}) (ref *TagSvgPolygon)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgPolygon) FontWeight 

func (e *TagSvgPolygon) FontWeight(value interface{}) (ref *TagSvgPolygon)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgPolygon) Get 

func (e *TagSvgPolygon) Get() (el js.Value)

func (*TagSvgPolygon) Html 

func (e *TagSvgPolygon) Html(value string) (ref *TagSvgPolygon)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgPolygon) Id 

func (e *TagSvgPolygon) Id(id string) (ref *TagSvgPolygon)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgPolygon) ImageRendering 

func (e *TagSvgPolygon) ImageRendering(imageRendering string) (ref *TagSvgPolygon)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgPolygon) Init 

func (e *TagSvgPolygon) Init() (ref *TagSvgPolygon)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgPolygon) Lang 

func (e *TagSvgPolygon) Lang(value interface{}) (ref *TagSvgPolygon)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgPolygon) LetterSpacing 

func (e *TagSvgPolygon) LetterSpacing(value float64) (ref *TagSvgPolygon)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgPolygon) LightingColor 

func (e *TagSvgPolygon) LightingColor(value interface{}) (ref *TagSvgPolygon)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgPolygon) MarkerEnd 

func (e *TagSvgPolygon) MarkerEnd(value interface{}) (ref *TagSvgPolygon)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgPolygon) MarkerMid 

func (e *TagSvgPolygon) MarkerMid(value interface{}) (ref *TagSvgPolygon)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgPolygon) MarkerStart 

func (e *TagSvgPolygon) MarkerStart(value interface{}) (ref *TagSvgPolygon)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgPolygon) Mask 

func (e *TagSvgPolygon) Mask(value interface{}) (ref *TagSvgPolygon)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgPolygon) Opacity 

func (e *TagSvgPolygon) Opacity(value interface{}) (ref *TagSvgPolygon)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgPolygon) Overflow 

func (e *TagSvgPolygon) Overflow(value interface{}) (ref *TagSvgPolygon)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgPolygon) PaintOrder 

func (e *TagSvgPolygon) PaintOrder(value interface{}) (ref *TagSvgPolygon)

PaintOrder

English:

The paint-order attribute specifies the order that the fill, stroke, and markers of a given shape or text element are painted. 

Input:
  value: specifies the order that the fill, stroke, and markers
    const: SvgPaintOrder... (e.g. KSvgPaintOrderStroke)
    any other type: interface{}

Notes:
  * As a presentation attribute, paint-order can be used as a CSS property.

Português:

O atributo paint-order especifica a ordem em que o preenchimento, o traçado e os marcadores de uma determinada forma ou elemento de texto são pintados. 

Entrada:
  value: especifica a ordem em que o preenchimento, o traçado e os marcadores
    const: SvgPaintOrder... (e.g. KSvgPaintOrderStroke)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, paint-order pode ser usado como uma propriedade CSS.

func (*TagSvgPolygon) PathLength 

func (e *TagSvgPolygon) PathLength(value interface{}) (ref *TagSvgPolygon)

PathLength

English:

The pathLength attribute lets authors specify a total length for the path, in user units. This value is then used to calibrate the browser's distance calculations with those of the author, by scaling all distance computations using the ratio pathLength/(computed value of path length).

This can affect the actual rendered lengths of paths; including text paths, animation paths, and various stroke operations. Basically, all computations that require the length of the path. stroke-dasharray, for example, will assume the start of the path being 0 and the end point the value defined in the pathLength attribute.

Português:

O atributo pathLength permite que os autores especifiquem um comprimento total para o caminho, em unidades de usuário. Este valor é então usado para calibrar os cálculos de distância do navegador com os do autor, escalando todos os cálculos de distância usando a razão pathLength (valor calculado do comprimento do caminho).

Isso pode afetar os comprimentos reais dos caminhos renderizados; incluindo caminhos de texto, caminhos de animação e várias operações de traçado. Basicamente, todos os cálculos que exigem o comprimento do caminho. stroke-dasharray, por exemplo, assumirá o início do caminho sendo 0 e o ponto final o valor definido no atributo pathLength.

func (*TagSvgPolygon) PointerEvents 

func (e *TagSvgPolygon) PointerEvents(value interface{}) (ref *TagSvgPolygon)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgPolygon) Points 

func (e *TagSvgPolygon) Points(value interface{}) (ref *TagSvgPolygon)

Points

English:

The points attribute defines a list of points. Each point is defined by a pair of number representing a X and a Y coordinate in the user coordinate system. If the attribute contains an odd number of coordinates, the last one will be ignored. 

Input:
  value: list of points representing coordinates X and Y
    [][]float64: [][]float64{{0,0},{1,1},{2,2}} = "0,0 1,1 2,2"
    any other type: interface{}

Português:

O atributo points define uma lista de pontos. Cada ponto é definido por um par de números representando uma coordenada X e Y no sistema de coordenadas do usuário. Se o atributo contiver um número ímpar de coordenadas, a última será ignorada. 

Entrada:
  value: lista de pontos representando as coordenadas X e Y
    [][]float64: [][]float64{{0,0},{1,1},{2,2}} = "0,0 1,1 2,2"
    qualquer outro tipo: interface{}

func (*TagSvgPolygon) ShapeRendering 

func (e *TagSvgPolygon) ShapeRendering(value interface{}) (ref *TagSvgPolygon)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgPolygon) StopColor 

func (e *TagSvgPolygon) StopColor(value interface{}) (ref *TagSvgPolygon)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgPolygon) StopOpacity 

func (e *TagSvgPolygon) StopOpacity(value interface{}) (ref *TagSvgPolygon)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgPolygon) Stroke 

func (e *TagSvgPolygon) Stroke(value interface{}) (ref *TagSvgPolygon)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgPolygon) StrokeDashOffset 

func (e *TagSvgPolygon) StrokeDashOffset(value interface{}) (ref *TagSvgPolygon)

StrokeDashOffset

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    float32: 0.1 = "10%"
    []float32: (e.g. []float32{0.04, 0.01, 0.02}) = "4% 1% 2%"
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    float32: 0.1 = "10%"
    []float32: (e.g. []float32{0.04, 0.01, 0.02}) = "4% 1% 2%"
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgPolygon) StrokeDasharray 

func (e *TagSvgPolygon) StrokeDasharray(value interface{}) (ref *TagSvgPolygon)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgPolygon) StrokeLineCap 

func (e *TagSvgPolygon) StrokeLineCap(value interface{}) (ref *TagSvgPolygon)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgPolygon) StrokeLineJoin 

func (e *TagSvgPolygon) StrokeLineJoin(value interface{}) (ref *TagSvgPolygon)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgPolygon) StrokeMiterLimit 

func (e *TagSvgPolygon) StrokeMiterLimit(value float64) (ref *TagSvgPolygon)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgPolygon) StrokeOpacity 

func (e *TagSvgPolygon) StrokeOpacity(value interface{}) (ref *TagSvgPolygon)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgPolygon) StrokeWidth 

func (e *TagSvgPolygon) StrokeWidth(value interface{}) (ref *TagSvgPolygon)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgPolygon) Style 

func (e *TagSvgPolygon) Style(value string) (ref *TagSvgPolygon)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgPolygon) Tabindex 

func (e *TagSvgPolygon) Tabindex(value int) (ref *TagSvgPolygon)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgPolygon) Text 

func (e *TagSvgPolygon) Text(value string) (ref *TagSvgPolygon)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgPolygon) TextAnchor 

func (e *TagSvgPolygon) TextAnchor(value interface{}) (ref *TagSvgPolygon)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgPolygon) TextDecoration 

func (e *TagSvgPolygon) TextDecoration(value interface{}) (ref *TagSvgPolygon)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgPolygon) TextRendering 

func (e *TagSvgPolygon) TextRendering(value interface{}) (ref *TagSvgPolygon)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgPolygon) Transform 

func (e *TagSvgPolygon) Transform(value interface{}) (ref *TagSvgPolygon)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgPolygon) UnicodeBidi 

func (e *TagSvgPolygon) UnicodeBidi(value interface{}) (ref *TagSvgPolygon)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgPolygon) VectorEffect 

func (e *TagSvgPolygon) VectorEffect(value interface{}) (ref *TagSvgPolygon)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgPolygon) Visibility 

func (e *TagSvgPolygon) Visibility(value interface{}) (ref *TagSvgPolygon)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgPolygon) WordSpacing 

func (e *TagSvgPolygon) WordSpacing(value interface{}) (ref *TagSvgPolygon)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgPolygon) WritingMode 

func (e *TagSvgPolygon) WritingMode(value interface{}) (ref *TagSvgPolygon)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgPolygon) XmlLang 

func (e *TagSvgPolygon) XmlLang(value interface{}) (ref *TagSvgPolygon)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

type TagSvgPolyline 

type TagSvgPolyline struct {
	// contains filtered or unexported fields
}

TagSvgPolyline

English:

The <polyline> SVG element is an SVG basic shape that creates straight lines connecting several points. Typically a polyline is used to create open shapes as the last point doesn't have to be connected to the first point.

For closed shapes see the <polygon> element.

Português:

O elemento SVG <polyline> é uma forma básica SVG que cria linhas retas conectando vários pontos. Normalmente, uma polilinha é usada para criar formas abertas, pois o último ponto não precisa ser conectado ao primeiro ponto.

Para formas fechadas veja o elemento <polygon>.

Para formas abertas, consulte o elemento <polyline>.

func (*TagSvgPolyline) Append 

func (e *TagSvgPolyline) Append(elements ...Compatible) (ref *TagSvgPolyline)

func (*TagSvgPolyline) AppendById 

func (e *TagSvgPolyline) AppendById(appendId string) (ref *TagSvgPolyline)

func (*TagSvgPolyline) AppendToElement 

func (e *TagSvgPolyline) AppendToElement(el js.Value) (ref *TagSvgPolyline)

func (*TagSvgPolyline) AppendToStage 

func (e *TagSvgPolyline) AppendToStage() (ref *TagSvgPolyline)

func (*TagSvgPolyline) BaselineShift 

func (e *TagSvgPolyline) BaselineShift(baselineShift interface{}) (ref *TagSvgPolyline)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgPolyline) Class 

func (e *TagSvgPolyline) Class(class string) (ref *TagSvgPolyline)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgPolyline) ClipPath 

func (e *TagSvgPolyline) ClipPath(clipPath string) (ref *TagSvgPolyline)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgPolyline) ClipRule 

func (e *TagSvgPolyline) ClipRule(value interface{}) (ref *TagSvgPolyline)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgPolyline) Color 

func (e *TagSvgPolyline) Color(value interface{}) (ref *TagSvgPolyline)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgPolyline) ColorInterpolation 

func (e *TagSvgPolyline) ColorInterpolation(value interface{}) (ref *TagSvgPolyline)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgPolyline) ColorInterpolationFilters 

func (e *TagSvgPolyline) ColorInterpolationFilters(value interface{}) (ref *TagSvgPolyline)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgPolyline) CreateElement 

func (e *TagSvgPolyline) CreateElement() (ref *TagSvgPolyline)

func (*TagSvgPolyline) Cursor 

func (e *TagSvgPolyline) Cursor(cursor SvgCursor) (ref *TagSvgPolyline)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgPolyline) Direction 

func (e *TagSvgPolyline) Direction(direction SvgDirection) (ref *TagSvgPolyline)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgPolyline) Display 

func (e *TagSvgPolyline) Display(value interface{}) (ref *TagSvgPolyline)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgPolyline) DominantBaseline 

func (e *TagSvgPolyline) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgPolyline)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgPolyline) Fill 

func (e *TagSvgPolyline) Fill(value interface{}) (ref *TagSvgPolyline)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgPolyline) FillOpacity 

func (e *TagSvgPolyline) FillOpacity(value interface{}) (ref *TagSvgPolyline)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgPolyline) FillRule 

func (e *TagSvgPolyline) FillRule(fillRule SvgFillRule) (ref *TagSvgPolyline)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgPolyline) Filter 

func (e *TagSvgPolyline) Filter(filter string) (ref *TagSvgPolyline)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgPolyline) FloodColor 

func (e *TagSvgPolyline) FloodColor(floodColor interface{}) (ref *TagSvgPolyline)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgPolyline) FloodOpacity 

func (e *TagSvgPolyline) FloodOpacity(floodOpacity float64) (ref *TagSvgPolyline)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgPolyline) FontFamily 

func (e *TagSvgPolyline) FontFamily(fontFamily string) (ref *TagSvgPolyline)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgPolyline) FontSize 

func (e *TagSvgPolyline) FontSize(fontSize interface{}) (ref *TagSvgPolyline)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgPolyline) FontSizeAdjust 

func (e *TagSvgPolyline) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgPolyline)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgPolyline) FontStretch 

func (e *TagSvgPolyline) FontStretch(fontStretch interface{}) (ref *TagSvgPolyline)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgPolyline) FontStyle 

func (e *TagSvgPolyline) FontStyle(fontStyle FontStyleRule) (ref *TagSvgPolyline)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgPolyline) FontVariant 

func (e *TagSvgPolyline) FontVariant(value interface{}) (ref *TagSvgPolyline)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgPolyline) FontWeight 

func (e *TagSvgPolyline) FontWeight(value interface{}) (ref *TagSvgPolyline)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgPolyline) Get 

func (e *TagSvgPolyline) Get() (el js.Value)

func (*TagSvgPolyline) Html 

func (e *TagSvgPolyline) Html(value string) (ref *TagSvgPolyline)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgPolyline) Id 

func (e *TagSvgPolyline) Id(id string) (ref *TagSvgPolyline)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgPolyline) ImageRendering 

func (e *TagSvgPolyline) ImageRendering(imageRendering string) (ref *TagSvgPolyline)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgPolyline) Init 

func (e *TagSvgPolyline) Init() (ref *TagSvgPolyline)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgPolyline) Lang 

func (e *TagSvgPolyline) Lang(value interface{}) (ref *TagSvgPolyline)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgPolyline) LetterSpacing 

func (e *TagSvgPolyline) LetterSpacing(value float64) (ref *TagSvgPolyline)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgPolyline) LightingColor 

func (e *TagSvgPolyline) LightingColor(value interface{}) (ref *TagSvgPolyline)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgPolyline) MarkerEnd 

func (e *TagSvgPolyline) MarkerEnd(value interface{}) (ref *TagSvgPolyline)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgPolyline) MarkerMid 

func (e *TagSvgPolyline) MarkerMid(value interface{}) (ref *TagSvgPolyline)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgPolyline) MarkerStart 

func (e *TagSvgPolyline) MarkerStart(value interface{}) (ref *TagSvgPolyline)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgPolyline) Mask 

func (e *TagSvgPolyline) Mask(value interface{}) (ref *TagSvgPolyline)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgPolyline) Opacity 

func (e *TagSvgPolyline) Opacity(value interface{}) (ref *TagSvgPolyline)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgPolyline) Overflow 

func (e *TagSvgPolyline) Overflow(value interface{}) (ref *TagSvgPolyline)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgPolyline) PaintOrder 

func (e *TagSvgPolyline) PaintOrder(value interface{}) (ref *TagSvgPolyline)

PaintOrder

English:

The paint-order attribute specifies the order that the fill, stroke, and markers of a given shape or text element are painted. 

Input:
  value: specifies the order that the fill, stroke, and markers
    const: SvgPaintOrder... (e.g. KSvgPaintOrderStroke)
    any other type: interface{}

Notes:
  * As a presentation attribute, paint-order can be used as a CSS property.

Português:

O atributo paint-order especifica a ordem em que o preenchimento, o traçado e os marcadores de uma determinada forma ou elemento de texto são pintados. 

Entrada:
  value: especifica a ordem em que o preenchimento, o traçado e os marcadores
    const: SvgPaintOrder... (e.g. KSvgPaintOrderStroke)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, paint-order pode ser usado como uma propriedade CSS.

func (*TagSvgPolyline) PathLength 

func (e *TagSvgPolyline) PathLength(value interface{}) (ref *TagSvgPolyline)

PathLength

English:

The pathLength attribute lets authors specify a total length for the path, in user units. This value is then used to calibrate the browser's distance calculations with those of the author, by scaling all distance computations using the ratio pathLength/(computed value of path length).

This can affect the actual rendered lengths of paths; including text paths, animation paths, and various stroke operations. Basically, all computations that require the length of the path. stroke-dasharray, for example, will assume the start of the path being 0 and the end point the value defined in the pathLength attribute.

Português:

O atributo pathLength permite que os autores especifiquem um comprimento total para o caminho, em unidades de usuário. Este valor é então usado para calibrar os cálculos de distância do navegador com os do autor, escalando todos os cálculos de distância usando a razão pathLength (valor calculado do comprimento do caminho).

Isso pode afetar os comprimentos reais dos caminhos renderizados; incluindo caminhos de texto, caminhos de animação e várias operações de traçado. Basicamente, todos os cálculos que exigem o comprimento do caminho. stroke-dasharray, por exemplo, assumirá o início do caminho sendo 0 e o ponto final o valor definido no atributo pathLength.

func (*TagSvgPolyline) PointerEvents 

func (e *TagSvgPolyline) PointerEvents(value interface{}) (ref *TagSvgPolyline)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgPolyline) Points 

func (e *TagSvgPolyline) Points(value interface{}) (ref *TagSvgPolyline)

Points

English:

The points attribute defines a list of points. Each point is defined by a pair of number representing a X and a Y coordinate in the user coordinate system. If the attribute contains an odd number of coordinates, the last one will be ignored. 

Input:
  value: list of points representing coordinates X and Y
    [][]float64: [][]float64{{0,0},{1,1},{2,2}} = "0,0 1,1 2,2"
    any other type: interface{}

Português:

O atributo points define uma lista de pontos. Cada ponto é definido por um par de números representando uma coordenada X e Y no sistema de coordenadas do usuário. Se o atributo contiver um número ímpar de coordenadas, a última será ignorada. 

Entrada:
  value: lista de pontos representando as coordenadas X e Y
    [][]float64: [][]float64{{0,0},{1,1},{2,2}} = "0,0 1,1 2,2"
    qualquer outro tipo: interface{}

func (*TagSvgPolyline) ShapeRendering 

func (e *TagSvgPolyline) ShapeRendering(value interface{}) (ref *TagSvgPolyline)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgPolyline) StopColor 

func (e *TagSvgPolyline) StopColor(value interface{}) (ref *TagSvgPolyline)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgPolyline) StopOpacity 

func (e *TagSvgPolyline) StopOpacity(value interface{}) (ref *TagSvgPolyline)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgPolyline) Stroke 

func (e *TagSvgPolyline) Stroke(value interface{}) (ref *TagSvgPolyline)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgPolyline) StrokeDashOffset 

func (e *TagSvgPolyline) StrokeDashOffset(value interface{}) (ref *TagSvgPolyline)

StrokeDashOffset

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    float32: 0.1 = "10%"
    []float32: (e.g. []float32{0.04, 0.01, 0.02}) = "4% 1% 2%"
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    float32: 0.1 = "10%"
    []float32: (e.g. []float32{0.04, 0.01, 0.02}) = "4% 1% 2%"
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgPolyline) StrokeDasharray 

func (e *TagSvgPolyline) StrokeDasharray(value interface{}) (ref *TagSvgPolyline)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgPolyline) StrokeLineCap 

func (e *TagSvgPolyline) StrokeLineCap(value interface{}) (ref *TagSvgPolyline)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgPolyline) StrokeLineJoin 

func (e *TagSvgPolyline) StrokeLineJoin(value interface{}) (ref *TagSvgPolyline)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgPolyline) StrokeMiterLimit 

func (e *TagSvgPolyline) StrokeMiterLimit(value float64) (ref *TagSvgPolyline)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgPolyline) StrokeOpacity 

func (e *TagSvgPolyline) StrokeOpacity(value interface{}) (ref *TagSvgPolyline)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgPolyline) StrokeWidth 

func (e *TagSvgPolyline) StrokeWidth(value interface{}) (ref *TagSvgPolyline)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgPolyline) Style 

func (e *TagSvgPolyline) Style(value string) (ref *TagSvgPolyline)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgPolyline) Tabindex 

func (e *TagSvgPolyline) Tabindex(value int) (ref *TagSvgPolyline)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgPolyline) Text 

func (e *TagSvgPolyline) Text(value string) (ref *TagSvgPolyline)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgPolyline) TextAnchor 

func (e *TagSvgPolyline) TextAnchor(value interface{}) (ref *TagSvgPolyline)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgPolyline) TextDecoration 

func (e *TagSvgPolyline) TextDecoration(value interface{}) (ref *TagSvgPolyline)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgPolyline) TextRendering 

func (e *TagSvgPolyline) TextRendering(value interface{}) (ref *TagSvgPolyline)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgPolyline) Transform 

func (e *TagSvgPolyline) Transform(value interface{}) (ref *TagSvgPolyline)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgPolyline) UnicodeBidi 

func (e *TagSvgPolyline) UnicodeBidi(value interface{}) (ref *TagSvgPolyline)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgPolyline) VectorEffect 

func (e *TagSvgPolyline) VectorEffect(value interface{}) (ref *TagSvgPolyline)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgPolyline) Visibility 

func (e *TagSvgPolyline) Visibility(value interface{}) (ref *TagSvgPolyline)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgPolyline) WordSpacing 

func (e *TagSvgPolyline) WordSpacing(value interface{}) (ref *TagSvgPolyline)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgPolyline) WritingMode 

func (e *TagSvgPolyline) WritingMode(value interface{}) (ref *TagSvgPolyline)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgPolyline) XmlLang 

func (e *TagSvgPolyline) XmlLang(value interface{}) (ref *TagSvgPolyline)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

type TagSvgRadialGradient 

type TagSvgRadialGradient struct {
	// contains filtered or unexported fields
}

TagSvgRadialGradient

English:

The <defs> element is used to store graphical objects that will be used at a later time.

Objects created inside a <defs> element are not rendered directly. To display them you have to reference them (with a <use> element for example).

Graphical objects can be referenced from anywhere, however, defining these objects inside of a <defs> element promotes understandability of the SVG content and is beneficial to the overall accessibility of the document.

Português:

O elemento <defs> é usado para armazenar objetos gráficos que serão usados posteriormente.

Objetos criados dentro de um elemento <defs> não são renderizados diretamente. Para exibi-los, você deve referenciá-los (com um elemento <use>, por exemplo).

Graphical objects can be referenced from anywhere, however, defining these objects inside of a <defs> element promotes understandability of the SVG content and is beneficial to the overall accessibility of the document.

func (*TagSvgRadialGradient) Append 

func (e *TagSvgRadialGradient) Append(elements ...Compatible) (ref *TagSvgRadialGradient)

func (*TagSvgRadialGradient) AppendById 

func (e *TagSvgRadialGradient) AppendById(appendId string) (ref *TagSvgRadialGradient)

func (*TagSvgRadialGradient) AppendToElement 

func (e *TagSvgRadialGradient) AppendToElement(el js.Value) (ref *TagSvgRadialGradient)

func (*TagSvgRadialGradient) AppendToStage 

func (e *TagSvgRadialGradient) AppendToStage() (ref *TagSvgRadialGradient)

func (*TagSvgRadialGradient) BaselineShift 

func (e *TagSvgRadialGradient) BaselineShift(baselineShift interface{}) (ref *TagSvgRadialGradient)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgRadialGradient) Class 

func (e *TagSvgRadialGradient) Class(class string) (ref *TagSvgRadialGradient)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgRadialGradient) ClipPath 

func (e *TagSvgRadialGradient) ClipPath(clipPath string) (ref *TagSvgRadialGradient)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgRadialGradient) ClipRule 

func (e *TagSvgRadialGradient) ClipRule(value interface{}) (ref *TagSvgRadialGradient)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgRadialGradient) Color 

func (e *TagSvgRadialGradient) Color(value interface{}) (ref *TagSvgRadialGradient)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgRadialGradient) ColorInterpolation 

func (e *TagSvgRadialGradient) ColorInterpolation(value interface{}) (ref *TagSvgRadialGradient)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgRadialGradient) ColorInterpolationFilters 

func (e *TagSvgRadialGradient) ColorInterpolationFilters(value interface{}) (ref *TagSvgRadialGradient)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgRadialGradient) CreateElement 

func (e *TagSvgRadialGradient) CreateElement() (ref *TagSvgRadialGradient)

func (*TagSvgRadialGradient) Cursor 

func (e *TagSvgRadialGradient) Cursor(cursor SvgCursor) (ref *TagSvgRadialGradient)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgRadialGradient) Cx 

func (e *TagSvgRadialGradient) Cx(value interface{}) (ref *TagSvgRadialGradient)

Cx

English: 

The cx attribute define the x-axis coordinate of a center point.

 Input:
   value: define the x-axis coordinate
     float32: 0.05 = "5%"
     any other type: interface{}

Português: 

O atributo cx define a coordenada do eixo x de um ponto central.

 Entrada:
   value: define a coordenada do eixo x
     float32: 0.05 = "5%"
     qualquer outro tipo: interface{}

func (*TagSvgRadialGradient) Cy 

func (e *TagSvgRadialGradient) Cy(value interface{}) (ref *TagSvgRadialGradient)

Cy

English:

The cy attribute define the y-axis coordinate of a center point. 

Input:
  value: define the y-axis coordinate
    float32: 0.05 = "5%"
    any other type: interface{}

Português: 

O atributo cy define a coordenada do eixo y de um ponto central.

 Entrada:
   value: define a coordenada do eixo y
     float32: 0.05 = "5%"
     qualquer outro tipo: interface{}

func (*TagSvgRadialGradient) Direction 

func (e *TagSvgRadialGradient) Direction(direction SvgDirection) (ref *TagSvgRadialGradient)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgRadialGradient) Display 

func (e *TagSvgRadialGradient) Display(value interface{}) (ref *TagSvgRadialGradient)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgRadialGradient) DominantBaseline 

func (e *TagSvgRadialGradient) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgRadialGradient)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgRadialGradient) Fill 

func (e *TagSvgRadialGradient) Fill(value interface{}) (ref *TagSvgRadialGradient)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgRadialGradient) FillOpacity 

func (e *TagSvgRadialGradient) FillOpacity(value interface{}) (ref *TagSvgRadialGradient)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgRadialGradient) FillRule 

func (e *TagSvgRadialGradient) FillRule(fillRule SvgFillRule) (ref *TagSvgRadialGradient)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgRadialGradient) Filter 

func (e *TagSvgRadialGradient) Filter(filter string) (ref *TagSvgRadialGradient)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgRadialGradient) FloodColor 

func (e *TagSvgRadialGradient) FloodColor(floodColor interface{}) (ref *TagSvgRadialGradient)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgRadialGradient) FloodOpacity 

func (e *TagSvgRadialGradient) FloodOpacity(floodOpacity float64) (ref *TagSvgRadialGradient)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgRadialGradient) FontFamily 

func (e *TagSvgRadialGradient) FontFamily(fontFamily string) (ref *TagSvgRadialGradient)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgRadialGradient) FontSize 

func (e *TagSvgRadialGradient) FontSize(fontSize interface{}) (ref *TagSvgRadialGradient)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgRadialGradient) FontSizeAdjust 

func (e *TagSvgRadialGradient) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgRadialGradient)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgRadialGradient) FontStretch 

func (e *TagSvgRadialGradient) FontStretch(fontStretch interface{}) (ref *TagSvgRadialGradient)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgRadialGradient) FontStyle 

func (e *TagSvgRadialGradient) FontStyle(fontStyle FontStyleRule) (ref *TagSvgRadialGradient)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgRadialGradient) FontVariant 

func (e *TagSvgRadialGradient) FontVariant(value interface{}) (ref *TagSvgRadialGradient)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgRadialGradient) FontWeight 

func (e *TagSvgRadialGradient) FontWeight(value interface{}) (ref *TagSvgRadialGradient)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgRadialGradient) Fr 

func (e *TagSvgRadialGradient) Fr(fr interface{}) (ref *TagSvgRadialGradient)

Fr

English: 

The fr attribute defines the radius of the focal point for the radial gradient.

 Input:
   fr: defines the radius of the focal point for the radial gradient
     float32: (e.g. 0.4 = 40%)
     string: "40%"

Portuguese 

O atributo fr define o raio do ponto focal para o gradiente radial.

 Entrada:
   fr: define o raio do ponto focal para o gradiente radial.
     float32: (ex. 0.4 = 40%)
     string: "40%"

func (*TagSvgRadialGradient) Fx 

func (e *TagSvgRadialGradient) Fx(value interface{}) (ref *TagSvgRadialGradient)

Fx

English: 

The fx attribute defines the x-axis coordinate of the focal point for a radial gradient.

 Input:
   value: the x-axis coordinate of the focal point for a radial gradient
     float32: 1.0 = "100%"
     any other type: interface{}

Portuguese 

O atributo fx define a coordenada do eixo x do ponto focal para um gradiente radial.

 Entrada:
   value: coordenada do eixo x do ponto focal para um gradiente radial
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

func (*TagSvgRadialGradient) Fy 

func (e *TagSvgRadialGradient) Fy(value interface{}) (ref *TagSvgRadialGradient)

Fy

English: 

The fy attribute defines the y-axis coordinate of the focal point for a radial gradient.

 Input:
   value: the y-axis coordinate of the focal point for a radial gradient
     float32: 1.0 = "100%"
     any other type: interface{}

Portuguese 

O atributo fy define a coordenada do eixo y do ponto focal para um gradiente radial.

 Entrada:
   value: coordenada do eixo y do ponto focal para um gradiente radial
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

func (*TagSvgRadialGradient) Get 

func (e *TagSvgRadialGradient) Get() (el js.Value)

func (*TagSvgRadialGradient) GradientTransform 

func (e *TagSvgRadialGradient) GradientTransform(value interface{}) (ref *TagSvgRadialGradient)

GradientTransform

English: 

The gradientTransform attribute contains the definition of an optional additional transformation from the gradient
coordinate system onto the target coordinate system (i.e., userSpaceOnUse or objectBoundingBox).

 Input:
   value: definition of an optional additional transformation from the gradient coordinate system
     Object: &html.TransformFunctions{}
     any other type: interface{}

This allows for things such as skewing the gradient. This additional transformation matrix is post-multiplied to
(i.e., inserted to the right of) any previously defined transformations, including the implicit transformation
necessary to convert from object bounding box units to user space.

Portuguese 

O atributo gradientTransform contém a definição de uma transformação adicional opcional do sistema de coordenadas
de gradiente para o sistema de coordenadas de destino (ou seja, userSpaceOnUse ou objectBoundingBox).

 Entrada:
   value: definição de uma transformação adicional opcional do sistema de coordenadas de gradiente
     Object: &html.TransformFunctions{}
     qualquer outro tipo: interface{}

Isso permite coisas como distorcer o gradiente. Essa matriz de transformação adicional é pós-multiplicada para
(ou seja, inserida à direita de) quaisquer transformações definidas anteriormente, incluindo a transformação
implícita necessária para converter de unidades de caixa delimitadora de objeto para espaço do usuário.

func (*TagSvgRadialGradient) GradientUnits 

func (e *TagSvgRadialGradient) GradientUnits(value interface{}) (ref *TagSvgRadialGradient)

GradientUnits

English: 

The gradientUnits attribute defines the coordinate system used for attributes specified on the gradient elements.

 Input:
   value: defines the coordinate system
     const: KSvgGradientUnits... (e.g. KSvgGradientUnitsUserSpaceOnUse)
     any other type: interface{}

Portuguese 

O atributo gradientUnits define o sistema de coordenadas usado para atributos especificados nos elementos
gradientes.

 Entrada:
   value: define o sistema de coordenadas
     const: KSvgGradientUnits... (ex. KSvgGradientUnitsUserSpaceOnUse)
     any other type: interface{}

func (*TagSvgRadialGradient) HRef 

func (e *TagSvgRadialGradient) HRef(href string) (ref *TagSvgRadialGradient)

HRef

English: 

The href attribute defines a link to a resource as a reference URL. The exact meaning of that link depends on the
context of each element using it.

 Notes:
   * Specifications before SVG 2 defined an xlink:href attribute, which is now rendered obsolete by the href
     attribute.
     If you need to support earlier browser versions, the deprecated xlink:href attribute can be used as a fallback
     in addition to the href attribute, e.g. <use href="some-id" xlink:href="some-id x="5" y="5" />.

Português: 

O atributo href define um link para um recurso como um URL de referência. O significado exato desse link depende do
contexto de cada elemento que o utiliza.

 Notas:
   * As especificações anteriores ao SVG 2 definiam um atributo xlink:href, que agora se torna obsoleto pelo
     atributo href.
     Se você precisar oferecer suporte a versões anteriores do navegador, o atributo obsoleto xlink:href pode ser
     usado como um substituto além do atributo href, por exemplo,
     <use href="some-id" xlink:href="some-id x="5" y="5" />.

func (*TagSvgRadialGradient) Html 

func (e *TagSvgRadialGradient) Html(value string) (ref *TagSvgRadialGradient)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgRadialGradient) Id 

func (e *TagSvgRadialGradient) Id(id string) (ref *TagSvgRadialGradient)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgRadialGradient) ImageRendering 

func (e *TagSvgRadialGradient) ImageRendering(imageRendering string) (ref *TagSvgRadialGradient)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgRadialGradient) Init 

func (e *TagSvgRadialGradient) Init() (ref *TagSvgRadialGradient)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgRadialGradient) Lang 

func (e *TagSvgRadialGradient) Lang(value interface{}) (ref *TagSvgRadialGradient)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgRadialGradient) LetterSpacing 

func (e *TagSvgRadialGradient) LetterSpacing(value float64) (ref *TagSvgRadialGradient)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgRadialGradient) LightingColor 

func (e *TagSvgRadialGradient) LightingColor(value interface{}) (ref *TagSvgRadialGradient)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgRadialGradient) MarkerEnd 

func (e *TagSvgRadialGradient) MarkerEnd(value interface{}) (ref *TagSvgRadialGradient)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgRadialGradient) MarkerMid 

func (e *TagSvgRadialGradient) MarkerMid(value interface{}) (ref *TagSvgRadialGradient)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgRadialGradient) MarkerStart 

func (e *TagSvgRadialGradient) MarkerStart(value interface{}) (ref *TagSvgRadialGradient)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgRadialGradient) Mask 

func (e *TagSvgRadialGradient) Mask(value interface{}) (ref *TagSvgRadialGradient)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgRadialGradient) Opacity 

func (e *TagSvgRadialGradient) Opacity(value interface{}) (ref *TagSvgRadialGradient)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgRadialGradient) Overflow 

func (e *TagSvgRadialGradient) Overflow(value interface{}) (ref *TagSvgRadialGradient)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgRadialGradient) PointerEvents 

func (e *TagSvgRadialGradient) PointerEvents(value interface{}) (ref *TagSvgRadialGradient)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgRadialGradient) R 

func (e *TagSvgRadialGradient) R(value interface{}) (ref *TagSvgRadialGradient)

R

English:

The r attribute defines the radius of a circle. 

Input:
  value: radius of a circle
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo r define o raio de um círculo. 

Input:
  value: raio de um círculo
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgRadialGradient) ShapeRendering 

func (e *TagSvgRadialGradient) ShapeRendering(value interface{}) (ref *TagSvgRadialGradient)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgRadialGradient) SpreadMethod 

func (e *TagSvgRadialGradient) SpreadMethod(value interface{}) (ref *TagSvgRadialGradient)

SpreadMethod

English:

The spreadMethod attribute determines how a shape is filled beyond the defined edges of a gradient. 

Input:
  value: determines how a shape is filled
    const: KSvgSpreadMethod... (e.g. KSvgSpreadMethodReflect)
    any other type: interface{}

Português:

O atributo spreadMethod determina como uma forma é preenchida além das bordas definidas de um gradiente. 

Entrada:
  value: determina como uma forma é preenchida
    const: KSvgSpreadMethod... (e.g. KSvgSpreadMethodReflect)
    qualquer outro tipo: interface{}

func (*TagSvgRadialGradient) StopColor 

func (e *TagSvgRadialGradient) StopColor(value interface{}) (ref *TagSvgRadialGradient)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgRadialGradient) StopOpacity 

func (e *TagSvgRadialGradient) StopOpacity(value interface{}) (ref *TagSvgRadialGradient)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgRadialGradient) Stroke 

func (e *TagSvgRadialGradient) Stroke(value interface{}) (ref *TagSvgRadialGradient)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgRadialGradient) StrokeDasharray 

func (e *TagSvgRadialGradient) StrokeDasharray(value interface{}) (ref *TagSvgRadialGradient)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgRadialGradient) StrokeLineCap 

func (e *TagSvgRadialGradient) StrokeLineCap(value interface{}) (ref *TagSvgRadialGradient)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgRadialGradient) StrokeLineJoin 

func (e *TagSvgRadialGradient) StrokeLineJoin(value interface{}) (ref *TagSvgRadialGradient)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgRadialGradient) StrokeMiterLimit 

func (e *TagSvgRadialGradient) StrokeMiterLimit(value float64) (ref *TagSvgRadialGradient)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgRadialGradient) StrokeOpacity 

func (e *TagSvgRadialGradient) StrokeOpacity(value interface{}) (ref *TagSvgRadialGradient)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgRadialGradient) StrokeWidth 

func (e *TagSvgRadialGradient) StrokeWidth(value interface{}) (ref *TagSvgRadialGradient)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgRadialGradient) Style 

func (e *TagSvgRadialGradient) Style(value string) (ref *TagSvgRadialGradient)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgRadialGradient) Tabindex 

func (e *TagSvgRadialGradient) Tabindex(value int) (ref *TagSvgRadialGradient)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgRadialGradient) Text 

func (e *TagSvgRadialGradient) Text(value string) (ref *TagSvgRadialGradient)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgRadialGradient) TextAnchor 

func (e *TagSvgRadialGradient) TextAnchor(value interface{}) (ref *TagSvgRadialGradient)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgRadialGradient) TextDecoration 

func (e *TagSvgRadialGradient) TextDecoration(value interface{}) (ref *TagSvgRadialGradient)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgRadialGradient) TextRendering 

func (e *TagSvgRadialGradient) TextRendering(value interface{}) (ref *TagSvgRadialGradient)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgRadialGradient) Transform 

func (e *TagSvgRadialGradient) Transform(value interface{}) (ref *TagSvgRadialGradient)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgRadialGradient) UnicodeBidi 

func (e *TagSvgRadialGradient) UnicodeBidi(value interface{}) (ref *TagSvgRadialGradient)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgRadialGradient) VectorEffect 

func (e *TagSvgRadialGradient) VectorEffect(value interface{}) (ref *TagSvgRadialGradient)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgRadialGradient) Visibility 

func (e *TagSvgRadialGradient) Visibility(value interface{}) (ref *TagSvgRadialGradient)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgRadialGradient) WordSpacing 

func (e *TagSvgRadialGradient) WordSpacing(value interface{}) (ref *TagSvgRadialGradient)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgRadialGradient) WritingMode 

func (e *TagSvgRadialGradient) WritingMode(value interface{}) (ref *TagSvgRadialGradient)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgRadialGradient) XLinkHRef deprecated 

func (e *TagSvgRadialGradient) XLinkHRef(value interface{}) (ref *TagSvgRadialGradient)

XLinkHRef

English:

Deprecated: use HRef() function

The xlink:href attribute defines a reference to a resource as a reference IRI. The exact meaning of that link depends on the context of each element using it. 

Notes:
  * SVG 2 removed the need for the xlink namespace, so instead of xlink:href you should use href. If you need to
    support earlier browser versions, the deprecated xlink:href attribute can be used as a fallback in addition to
    the href attribute, e.g. <use href="some-id" xlink:href="some-id" x="5" y="5" />.

Português:

Obsoleto: use a função HRef()

O atributo xlink:href define uma referência a um recurso como um IRI de referência. O significado exato desse link depende do contexto de cada elemento que o utiliza. 

Notas:
  * O SVG 2 removeu a necessidade do namespace xlink, então ao invés de xlink:href você deve usar href. Se você
    precisar oferecer suporte a versões anteriores do navegador, o atributo obsoleto xlink:href pode ser usado como
    um substituto além do atributo href, por exemplo, <use href="some-id" xlink:href="some-id" x="5" y="5" >.

func (*TagSvgRadialGradient) XmlLang 

func (e *TagSvgRadialGradient) XmlLang(value interface{}) (ref *TagSvgRadialGradient)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

type TagSvgRect 

type TagSvgRect struct {
	// contains filtered or unexported fields
}

TagSvgRect

English:

The <rect> element is a basic SVG shape that draws rectangles, defined by their position, width, and height. The rectangles may have their corners rounded.

Português:

O elemento <rect> é uma forma SVG básica que desenha retângulos, definidos por sua posição, largura e altura. Os retângulos podem ter seus cantos arredondados.

func (*TagSvgRect) Append 

func (e *TagSvgRect) Append(elements ...Compatible) (ref *TagSvgRect)

func (*TagSvgRect) AppendById 

func (e *TagSvgRect) AppendById(appendId string) (ref *TagSvgRect)

func (*TagSvgRect) AppendToElement 

func (e *TagSvgRect) AppendToElement(el js.Value) (ref *TagSvgRect)

func (*TagSvgRect) AppendToStage 

func (e *TagSvgRect) AppendToStage() (ref *TagSvgRect)

func (*TagSvgRect) BaselineShift 

func (e *TagSvgRect) BaselineShift(baselineShift interface{}) (ref *TagSvgRect)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgRect) Class 

func (e *TagSvgRect) Class(class string) (ref *TagSvgRect)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgRect) ClipPath 

func (e *TagSvgRect) ClipPath(clipPath string) (ref *TagSvgRect)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgRect) ClipRule 

func (e *TagSvgRect) ClipRule(value interface{}) (ref *TagSvgRect)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgRect) Color 

func (e *TagSvgRect) Color(value interface{}) (ref *TagSvgRect)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgRect) ColorInterpolation 

func (e *TagSvgRect) ColorInterpolation(value interface{}) (ref *TagSvgRect)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgRect) ColorInterpolationFilters 

func (e *TagSvgRect) ColorInterpolationFilters(value interface{}) (ref *TagSvgRect)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgRect) CreateElement 

func (e *TagSvgRect) CreateElement() (ref *TagSvgRect)

func (*TagSvgRect) Cursor 

func (e *TagSvgRect) Cursor(cursor SvgCursor) (ref *TagSvgRect)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgRect) Direction 

func (e *TagSvgRect) Direction(direction SvgDirection) (ref *TagSvgRect)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgRect) Display 

func (e *TagSvgRect) Display(value interface{}) (ref *TagSvgRect)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgRect) DominantBaseline 

func (e *TagSvgRect) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgRect)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgRect) Fill 

func (e *TagSvgRect) Fill(value interface{}) (ref *TagSvgRect)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgRect) FillOpacity 

func (e *TagSvgRect) FillOpacity(value interface{}) (ref *TagSvgRect)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgRect) FillRule 

func (e *TagSvgRect) FillRule(fillRule SvgFillRule) (ref *TagSvgRect)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgRect) Filter 

func (e *TagSvgRect) Filter(filter string) (ref *TagSvgRect)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgRect) FloodColor 

func (e *TagSvgRect) FloodColor(floodColor interface{}) (ref *TagSvgRect)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgRect) FloodOpacity 

func (e *TagSvgRect) FloodOpacity(floodOpacity float64) (ref *TagSvgRect)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgRect) FontFamily 

func (e *TagSvgRect) FontFamily(fontFamily string) (ref *TagSvgRect)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgRect) FontSize 

func (e *TagSvgRect) FontSize(fontSize interface{}) (ref *TagSvgRect)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgRect) FontSizeAdjust 

func (e *TagSvgRect) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgRect)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgRect) FontStretch 

func (e *TagSvgRect) FontStretch(fontStretch interface{}) (ref *TagSvgRect)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgRect) FontStyle 

func (e *TagSvgRect) FontStyle(fontStyle FontStyleRule) (ref *TagSvgRect)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgRect) FontVariant 

func (e *TagSvgRect) FontVariant(value interface{}) (ref *TagSvgRect)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgRect) FontWeight 

func (e *TagSvgRect) FontWeight(value interface{}) (ref *TagSvgRect)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgRect) Get 

func (e *TagSvgRect) Get() (el js.Value)

func (*TagSvgRect) Height 

func (e *TagSvgRect) Height(height interface{}) (ref *TagSvgRect)

Height

English: 

The height attribute defines the vertical length of an element in the user coordinate system.
     float32: 1.0 = "100%"
     any other type: interface{}

Português: 

O atributo height define o comprimento vertical de um elemento no sistema de coordenadas do usuário.
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

func (*TagSvgRect) Html 

func (e *TagSvgRect) Html(value string) (ref *TagSvgRect)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgRect) Id 

func (e *TagSvgRect) Id(id string) (ref *TagSvgRect)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgRect) ImageRendering 

func (e *TagSvgRect) ImageRendering(imageRendering string) (ref *TagSvgRect)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgRect) Init 

func (e *TagSvgRect) Init() (ref *TagSvgRect)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgRect) Lang 

func (e *TagSvgRect) Lang(value interface{}) (ref *TagSvgRect)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgRect) LetterSpacing 

func (e *TagSvgRect) LetterSpacing(value float64) (ref *TagSvgRect)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgRect) LightingColor 

func (e *TagSvgRect) LightingColor(value interface{}) (ref *TagSvgRect)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgRect) MarkerEnd 

func (e *TagSvgRect) MarkerEnd(value interface{}) (ref *TagSvgRect)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgRect) MarkerMid 

func (e *TagSvgRect) MarkerMid(value interface{}) (ref *TagSvgRect)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgRect) MarkerStart 

func (e *TagSvgRect) MarkerStart(value interface{}) (ref *TagSvgRect)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgRect) Mask 

func (e *TagSvgRect) Mask(value interface{}) (ref *TagSvgRect)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgRect) Opacity 

func (e *TagSvgRect) Opacity(value interface{}) (ref *TagSvgRect)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgRect) Overflow 

func (e *TagSvgRect) Overflow(value interface{}) (ref *TagSvgRect)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgRect) PaintOrder 

func (e *TagSvgRect) PaintOrder(value interface{}) (ref *TagSvgRect)

PaintOrder

English:

The paint-order attribute specifies the order that the fill, stroke, and markers of a given shape or text element are painted. 

Input:
  value: specifies the order that the fill, stroke, and markers
    const: SvgPaintOrder... (e.g. KSvgPaintOrderStroke)
    any other type: interface{}

Notes:
  * As a presentation attribute, paint-order can be used as a CSS property.

Português:

O atributo paint-order especifica a ordem em que o preenchimento, o traçado e os marcadores de uma determinada forma ou elemento de texto são pintados. 

Entrada:
  value: especifica a ordem em que o preenchimento, o traçado e os marcadores
    const: SvgPaintOrder... (e.g. KSvgPaintOrderStroke)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, paint-order pode ser usado como uma propriedade CSS.

func (*TagSvgRect) PathLength 

func (e *TagSvgRect) PathLength(value interface{}) (ref *TagSvgRect)

PathLength

English:

The pathLength attribute lets authors specify a total length for the path, in user units. This value is then used to calibrate the browser's distance calculations with those of the author, by scaling all distance computations using the ratio pathLength/(computed value of path length).

This can affect the actual rendered lengths of paths; including text paths, animation paths, and various stroke operations. Basically, all computations that require the length of the path. stroke-dasharray, for example, will assume the start of the path being 0 and the end point the value defined in the pathLength attribute.

Português:

O atributo pathLength permite que os autores especifiquem um comprimento total para o caminho, em unidades de usuário. Este valor é então usado para calibrar os cálculos de distância do navegador com os do autor, escalando todos os cálculos de distância usando a razão pathLength (valor calculado do comprimento do caminho).

Isso pode afetar os comprimentos reais dos caminhos renderizados; incluindo caminhos de texto, caminhos de animação e várias operações de traçado. Basicamente, todos os cálculos que exigem o comprimento do caminho. stroke-dasharray, por exemplo, assumirá o início do caminho sendo 0 e o ponto final o valor definido no atributo pathLength.

func (*TagSvgRect) PointerEvents 

func (e *TagSvgRect) PointerEvents(value interface{}) (ref *TagSvgRect)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgRect) Rx 

func (e *TagSvgRect) Rx(value float64) (ref *TagSvgRect)

Rx

English:

The rx attribute defines a radius on the x-axis.

Português:

O atributo rx define um raio no eixo x.

func (*TagSvgRect) Ry 

func (e *TagSvgRect) Ry(value float64) (ref *TagSvgRect)

Ry

English:

The ry attribute defines a radius on the y-axis.

Português:

O atributo ry define um raio no eixo y.

func (*TagSvgRect) ShapeRendering 

func (e *TagSvgRect) ShapeRendering(value interface{}) (ref *TagSvgRect)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgRect) StopColor 

func (e *TagSvgRect) StopColor(value interface{}) (ref *TagSvgRect)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgRect) StopOpacity 

func (e *TagSvgRect) StopOpacity(value interface{}) (ref *TagSvgRect)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgRect) Stroke 

func (e *TagSvgRect) Stroke(value interface{}) (ref *TagSvgRect)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgRect) StrokeDashOffset 

func (e *TagSvgRect) StrokeDashOffset(value interface{}) (ref *TagSvgRect)

StrokeDashOffset

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    float32: 0.1 = "10%"
    []float32: (e.g. []float32{0.04, 0.01, 0.02}) = "4% 1% 2%"
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    float32: 0.1 = "10%"
    []float32: (e.g. []float32{0.04, 0.01, 0.02}) = "4% 1% 2%"
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgRect) StrokeDasharray 

func (e *TagSvgRect) StrokeDasharray(value interface{}) (ref *TagSvgRect)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgRect) StrokeLineCap 

func (e *TagSvgRect) StrokeLineCap(value interface{}) (ref *TagSvgRect)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgRect) StrokeLineJoin 

func (e *TagSvgRect) StrokeLineJoin(value interface{}) (ref *TagSvgRect)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgRect) StrokeMiterLimit 

func (e *TagSvgRect) StrokeMiterLimit(value float64) (ref *TagSvgRect)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgRect) StrokeOpacity 

func (e *TagSvgRect) StrokeOpacity(value interface{}) (ref *TagSvgRect)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgRect) StrokeWidth 

func (e *TagSvgRect) StrokeWidth(value interface{}) (ref *TagSvgRect)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgRect) Style 

func (e *TagSvgRect) Style(value string) (ref *TagSvgRect)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgRect) Tabindex 

func (e *TagSvgRect) Tabindex(value int) (ref *TagSvgRect)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgRect) Text 

func (e *TagSvgRect) Text(value string) (ref *TagSvgRect)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgRect) TextAnchor 

func (e *TagSvgRect) TextAnchor(value interface{}) (ref *TagSvgRect)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgRect) TextDecoration 

func (e *TagSvgRect) TextDecoration(value interface{}) (ref *TagSvgRect)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgRect) TextRendering 

func (e *TagSvgRect) TextRendering(value interface{}) (ref *TagSvgRect)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgRect) Transform 

func (e *TagSvgRect) Transform(value interface{}) (ref *TagSvgRect)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgRect) UnicodeBidi 

func (e *TagSvgRect) UnicodeBidi(value interface{}) (ref *TagSvgRect)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgRect) VectorEffect 

func (e *TagSvgRect) VectorEffect(value interface{}) (ref *TagSvgRect)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgRect) Visibility 

func (e *TagSvgRect) Visibility(value interface{}) (ref *TagSvgRect)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgRect) Width 

func (e *TagSvgRect) Width(value interface{}) (ref *TagSvgRect)

Width

English:

The width attribute defines the horizontal length of an element in the user coordinate system. 

Input:
  value: the horizontal length of an element
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo largura define o comprimento horizontal de um elemento no sistema de coordenadas do usuário. 

Entrada:
  value: o comprimento horizontal de um elemento
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgRect) WordSpacing 

func (e *TagSvgRect) WordSpacing(value interface{}) (ref *TagSvgRect)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgRect) WritingMode 

func (e *TagSvgRect) WritingMode(value interface{}) (ref *TagSvgRect)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgRect) X 

func (e *TagSvgRect) X(value interface{}) (ref *TagSvgRect)

X

English:

The x attribute defines an x-axis coordinate in the user coordinate system. 

Input:
  value: defines an x-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo x define uma coordenada do eixo x no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo x
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgRect) XmlLang 

func (e *TagSvgRect) XmlLang(value interface{}) (ref *TagSvgRect)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

func (*TagSvgRect) Y 

func (e *TagSvgRect) Y(value interface{}) (ref *TagSvgRect)

Y

English:

The y attribute defines an y-axis coordinate in the user coordinate system. 

Input:
  value: defines an y-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo y define uma coordenada do eixo y no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo y
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

type TagSvgScript 

type TagSvgScript struct {
	// contains filtered or unexported fields
}

TagSvgScript

English:

The SVG script element allows to add scripts to an SVG document. 

Notes:
  * While SVG's script element is equivalent to the HTML <script> element, it has some discrepancies, like it uses
    the href attribute instead of src and it doesn't support ECMAScript modules so far (See browser compatibility
    below for details)
  * document/window.addEventListener("DOMContentLoaded", (e) => {...}); - didn't work in tests (07/2022)

Português:

O elemento script SVG permite adicionar scripts a um documento SVG. 

Notas:
  * Embora o elemento script do SVG seja equivalente ao elemento HTML <script>, ele tem algumas discrepâncias, como
    usar o atributo href em vez de src e não suportar módulos ECMAScript até agora (consulte a compatibilidade do
    navegador abaixo para obter detalhes)
  * document/window.addEventListener("DOMContentLoaded", (e) => {...}); - não funcionou nos testes (07/2022)

func (*TagSvgScript) Append 

func (e *TagSvgScript) Append(elements ...Compatible) (ref *TagSvgScript)

func (*TagSvgScript) AppendById 

func (e *TagSvgScript) AppendById(appendId string) (ref *TagSvgScript)

func (*TagSvgScript) AppendToElement 

func (e *TagSvgScript) AppendToElement(el js.Value) (ref *TagSvgScript)

func (*TagSvgScript) AppendToStage 

func (e *TagSvgScript) AppendToStage() (ref *TagSvgScript)

func (*TagSvgScript) Class 

func (e *TagSvgScript) Class(class string) (ref *TagSvgScript)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgScript) CreateElement 

func (e *TagSvgScript) CreateElement() (ref *TagSvgScript)

func (*TagSvgScript) CrossOrigin 

func (e *TagSvgScript) CrossOrigin(crossOrigin SvgCrossOrigin) (ref *TagSvgScript)

CrossOrigin

English: 

The crossorigin attribute, valid on the <image> element, provides support for CORS, defining how the element handles
crossorigin requests, thereby enabling the configuration of the CORS requests for the element's fetched data. It is
a CORS settings attribute.

Português: 

The crossorigin attribute, valid on the <image> element, provides support for CORS, defining how the element handles
crossorigin requests, thereby enabling the configuration of the CORS requests for the element's fetched data. It is
a CORS settings attribute.

func (*TagSvgScript) Get 

func (e *TagSvgScript) Get() (el js.Value)

func (*TagSvgScript) HRef 

func (e *TagSvgScript) HRef(href string) (ref *TagSvgScript)

HRef

English: 

The href attribute defines a link to a resource as a reference URL. The exact meaning of that link depends on the
context of each element using it.

 Notes:
   * Specifications before SVG 2 defined an xlink:href attribute, which is now rendered obsolete by the href
     attribute.
     If you need to support earlier browser versions, the deprecated xlink:href attribute can be used as a fallback
     in addition to the href attribute, e.g. <use href="some-id" xlink:href="some-id x="5" y="5" />.

Português: 

O atributo href define um link para um recurso como um URL de referência. O significado exato desse link depende do
contexto de cada elemento que o utiliza.

 Notas:
   * As especificações anteriores ao SVG 2 definiam um atributo xlink:href, que agora se torna obsoleto pelo
     atributo href.
     Se você precisar oferecer suporte a versões anteriores do navegador, o atributo obsoleto xlink:href pode ser
     usado como um substituto além do atributo href, por exemplo,
     <use href="some-id" xlink:href="some-id x="5" y="5" />.

func (*TagSvgScript) Id 

func (e *TagSvgScript) Id(id string) (ref *TagSvgScript)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgScript) Init 

func (e *TagSvgScript) Init() (ref *TagSvgScript)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgScript) Lang 

func (e *TagSvgScript) Lang(value interface{}) (ref *TagSvgScript)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgScript) Script 

func (e *TagSvgScript) Script(value string) (ref *TagSvgScript)

Script

English:

Adds plain text to the tag's content. 

Notes:
  * document/window.addEventListener("DOMContentLoaded", (e) => {...}); - didn't work in tests (07/2022)

Text:

Adiciona um texto simples ao conteúdo da tag. 

Notras:
  * document/window.addEventListener("DOMContentLoaded", (e) => {...}); - não funcionou nos testes (07/2022)

func (*TagSvgScript) Style 

func (e *TagSvgScript) Style(value string) (ref *TagSvgScript)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgScript) Tabindex 

func (e *TagSvgScript) Tabindex(value int) (ref *TagSvgScript)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgScript) Type 

func (e *TagSvgScript) Type(value interface{}) (ref *TagSvgScript)

Type

English:

Defines the content type of the element. 

Input:
  value: type of the element

Português:

Define o tipo de conteúdo do elemento. 

Input:
  value: tipo de conteúdo do elemento

func (*TagSvgScript) XLinkHRef deprecated 

func (e *TagSvgScript) XLinkHRef(value interface{}) (ref *TagSvgScript)

XLinkHRef

English:

Deprecated: use HRef() function

The xlink:href attribute defines a reference to a resource as a reference IRI. The exact meaning of that link depends on the context of each element using it. 

Notes:
  * SVG 2 removed the need for the xlink namespace, so instead of xlink:href you should use href. If you need to
    support earlier browser versions, the deprecated xlink:href attribute can be used as a fallback in addition to
    the href attribute, e.g. <use href="some-id" xlink:href="some-id" x="5" y="5" />.

Português:

Obsoleto: use a função HRef()

O atributo xlink:href define uma referência a um recurso como um IRI de referência. O significado exato desse link depende do contexto de cada elemento que o utiliza. 

Notas:
  * O SVG 2 removeu a necessidade do namespace xlink, então ao invés de xlink:href você deve usar href. Se você
    precisar oferecer suporte a versões anteriores do navegador, o atributo obsoleto xlink:href pode ser usado como
    um substituto além do atributo href, por exemplo, <use href="some-id" xlink:href="some-id" x="5" y="5" >.

func (*TagSvgScript) XmlLang 

func (e *TagSvgScript) XmlLang(value interface{}) (ref *TagSvgScript)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

type TagSvgSet 

type TagSvgSet struct {
	// contains filtered or unexported fields
}

TagSvgSet

English:

The SVG <set> element provides a simple means of just setting the value of an attribute for a specified duration.

It supports all attribute types, including those that cannot reasonably be interpolated, such as string and boolean values. For attributes that can be reasonably be interpolated, the <animate> is usually preferred. 

Notes:
  * The <set> element is non-additive. The additive and accumulate attributes are not allowed, and will be
    ignored if specified.

Português:

O elemento SVG <set> fornece um meio simples de apenas definir o valor de um atributo para uma duração especificada.

Ele suporta todos os tipos de atributos, incluindo aqueles que não podem ser interpolados de maneira razoável, como valores de string e booleanos. Para atributos que podem ser razoavelmente interpolados, o <animate> geralmente é preferido. 

Notas:
  * O elemento <set> não é aditivo. Os atributos aditivo e acumular não são permitidos e serão ignorados se
    especificados.

func (*TagSvgSet) Accumulate 

func (e *TagSvgSet) Accumulate(value interface{}) (ref *TagSvgSet)

Accumulate

English: 

The accumulate attribute controls whether or not an animation is cumulative.

 Input:
   value: controls whether or not an animation is cumulative
     const: KSvgAccumulate... (e.g. KSvgAccumulateSum)
     any other type: interface{}

It is frequently useful for repeated animations to build upon the previous results, accumulating with each iteration. This attribute said to the animation if the value is added to the previous animated attribute's value on each iteration. 

Notes:
  * This attribute is ignored if the target attribute value does not support addition, or if the animation element
    does not repeat;
  * This attribute will be ignored if the animation function is specified with only the to attribute.

Português: 

O atributo acumular controla se uma animação é cumulativa ou não.

 Entrada:
   value: controla se uma animação é cumulativa ou não
     const: KSvgAccumulate... (ex. KSvgAccumulateSum)
     qualquer outro tipo: interface{}

Frequentemente, é útil que as animações repetidas se baseiem nos resultados anteriores, acumulando a cada iteração. Este atributo é dito à animação se o valor for adicionado ao valor do atributo animado anterior em cada iteração. 

Notas:
  * Esse atributo será ignorado se o valor do atributo de destino não suportar adição ou se o elemento de animação
    não se repetir;
  * Este atributo será ignorado se a função de animação for especificada apenas com o atributo to.

func (*TagSvgSet) Additive 

func (e *TagSvgSet) Additive(value interface{}) (ref *TagSvgSet)

Additive

English: 

The additive attribute controls whether or not an animation is additive.

 Input:
   value: controls whether or not an animation is additive
     const: KSvgAdditive... (e.g. KSvgAdditiveSum)
     any other type: interface{}

It is frequently useful to define animation as an offset or delta to an attribute's value, rather than as absolute values.

Português: 

O atributo aditivo controla se uma animação é ou não aditiva.

 Entrada:
   value: controla se uma animação é aditiva ou não
     const: KSvgAdditive... (ex. KSvgAdditiveSum)
     qualquer outro tipo: interface{}

É frequentemente útil definir a animação como um deslocamento ou delta para o valor de um atributo, em vez de valores absolutos.

func (*TagSvgSet) Append 

func (e *TagSvgSet) Append(elements ...Compatible) (ref *TagSvgSet)

func (*TagSvgSet) AppendById 

func (e *TagSvgSet) AppendById(appendId string) (ref *TagSvgSet)

func (*TagSvgSet) AppendToElement 

func (e *TagSvgSet) AppendToElement(el js.Value) (ref *TagSvgSet)

func (*TagSvgSet) AppendToStage 

func (e *TagSvgSet) AppendToStage() (ref *TagSvgSet)

func (*TagSvgSet) AttributeName 

func (e *TagSvgSet) AttributeName(attributeName string) (ref *TagSvgSet)

AttributeName

English: 

The attributeName attribute indicates the name of the CSS property or attribute of the target element that is going
to be changed during an animation.

Português: 

O atributo attributeName indica o nome da propriedade CSS ou atributo do elemento de destino que será alterado
durante uma animação.

func (*TagSvgSet) Begin 

func (e *TagSvgSet) Begin(begin interface{}) (ref *TagSvgSet)

Begin

English: 

The begin attribute defines when an animation should begin or when an element should be discarded.

 Input:
   begin: defines when an animation should begin or when an element should be discarded.
     offset-value: This value defines a clock-value that represents a point in time relative to the beginning of the
       SVG document (usually the load or DOMContentLoaded event). Negative values are valid.
       (e.g. time.Second*5 or "5s")
     syncbase-value: This value defines a syncbase and an optional offset from that syncbase. The element's
       animation start time is defined relative to the begin or active end of another animation.
       A valid syncbase-value consists of an ID reference to another animation element followed by a dot and either
       begin or end to identify whether to synchronize with the beginning or active end of the referenced animation
       element. An optional offset value as defined in <offset-value> can be appended.
       (e.g. "0s;third.end", "first.end" or "second.end")
     event-value: This value defines an event and an optional offset that determines the time at which the element's
       animation should begin. The animation start time is defined relative to the time that the specified event is
       fired.
       A valid event-value consists of an element ID followed by a dot and one of the supported events for that
       element. All valid events (not necessarily supported by all elements) are defined by the DOM and HTML
       specifications. Those are: 'focus', 'blur', 'focusin', 'focusout', 'activate', 'auxclick', 'click',
       'dblclick', 'mousedown', 'mouseenter', 'mouseleave', 'mousemove', 'mouseout', 'mouseover', 'mouseup',
       'wheel', 'beforeinput', 'input', 'keydown', 'keyup', 'compositionstart', 'compositionupdate',
       'compositionend', 'load', 'unload', 'abort', 'error', 'select', 'resize', 'scroll', 'beginEvent', 'endEvent',
       and 'repeatEvent'. An optional offset value as defined in <offset-value> can be appended.
       (e.g. "startButton.click")
     repeat-value: This value defines a qualified repeat event. The element animation start time is defined relative
       to the time that the repeat event is raised with the specified iteration value.
       A valid repeat value consists of an element ID followed by a dot and the function repeat() with an integer
       value specifying the number of repetitions as parameter. An optional offset value as defined in
       <offset-value> can be appended.
       (e.g. "0s;myLoop.end", "myLoop.begin", "myLoop.repeat(1)" or "myLoop.repeat(2)")
     accessKey-value: This value defines an access key that should trigger the animation. The element animation will
       begin when the user presses the specified key.
       A valid accessKey-value consists of the function accessKey() with the character to be input as parameter. An
       optional offset value as defined in <offset-value> can be appended.
       (e.g. "accessKey(s)")
     wallclock-sync-value: This value defines the animation start time as a real-world clock time.
       A valid wallclock-sync-value consists of the function wallclock() with a time value as parameter. The time
       syntax is based upon the syntax defined in ISO 8601.
       (e.g. time.Now() )
     indefinite: The begin of the animation will be determined by a beginElement() method call or a hyperlink
       targeted to the element.
       (e.g. "infinite")

The attribute value is a semicolon separated list of values. The interpretation of a list of start times is detailed in the SMIL specification in "Evaluation of begin and end time lists". Each individual value can be one of the following: <offset-value>, <syncbase-value>, <event-value>, <repeat-value>, <accessKey-value>, <wallclock-sync-value> or the keyword 'indefinite'.

Português: 

O atributo begin define quando uma animação deve começar ou quando um elemento deve ser descartado.

 Entrada:
   begin: define quando uma animação deve começar ou quando um elemento deve ser descartado.
     offset-value: Esse valor define um valor de relógio que representa um ponto no tempo relativo ao início do
       documento SVG (geralmente o evento load ou DOMContentLoaded). Valores negativos são válidos.
       (e.g. time.Second*5 or "5s")
     syncbase-value: Esse valor define uma base de sincronização e um deslocamento opcional dessa base de
       sincronização. A hora de início da animação do elemento é definida em relação ao início ou fim ativo de outra
       animação.
       Um valor syncbase válido consiste em uma referência de ID para outro elemento de animação seguido por um
       ponto e um início ou fim para identificar se deve ser sincronizado com o início ou o final ativo do elemento
       de animação referenciado. Um valor de deslocamento opcional conforme definido em <offset-value> pode ser
       anexado.
       (e.g. "0s;third.end", "first.end" or "second.end")
     event-value: Esse valor define um evento e um deslocamento opcional que determina a hora em que a animação do
       elemento deve começar. A hora de início da animação é definida em relação à hora em que o evento especificado
       é acionado.
       Um valor de evento válido consiste em um ID de elemento seguido por um ponto e um dos eventos com suporte
       para esse elemento. Todos os eventos válidos (não necessariamente suportados por todos os elementos) são
       definidos pelas especificações DOM e HTML. Esses valores são: 'focus', 'blur', 'focusin', 'focusout',
       'activate', 'auxclick', 'click', 'dblclick', 'mousedown', 'mouseenter', 'mouseleave', 'mousemove',
       'mouseout', 'mouseover', 'mouseup', 'wheel', 'beforeinput', 'input', 'keydown', 'keyup', 'compositionstart',
       'compositionupdate', 'compositionend', 'load', 'unload', 'abort', 'error', 'select', 'resize', 'scroll',
       'beginEvent', 'endEvent', e 'repeatEvent'. Um valor de deslocamento opcional conforme definido em
       <offset-value> pode ser anexado.
       (e.g. "startButton.click")
     repeat-value: Esse valor define um evento de repetição qualificado. A hora de início da animação do elemento é
       definida em relação à hora em que o evento de repetição é gerado com o valor de iteração especificado.
       Um valor de repetição válido consiste em um ID de elemento seguido por um ponto e a função repeat() com um
       valor inteiro especificando o número de repetições como parâmetro. Um valor de deslocamento opcional conforme
       definido em <offset-value> pode ser anexado.
       (e.g. "0s;myLoop.end", "myLoop.begin", "myLoop.repeat(1)" or "myLoop.repeat(2)")
     accessKey-value: Este valor define uma chave de acesso que deve acionar a animação. A animação do elemento
       começará quando o usuário pressionar a tecla especificada.
       Um valor válido de accessKey consiste na função accessKey() com o caractere a ser inserido como parâmetro.
       Um valor de deslocamento opcional conforme definido em <valor de deslocamento> pode ser anexado.
       (e.g. "accessKey(s)")
     wallclock-sync-value: Esse valor define a hora de início da animação como uma hora do relógio do mundo real.
       Um valor wallclock-sync válido consiste na função wallclock() com um valor de tempo como parâmetro. A sintaxe
       de tempo é baseada na sintaxe definida na ISO 8601.
       (e.g. time.Now() )
     indefinite: O início da animação será determinado por uma chamada de método beginElement() ou um hiperlink
       direcionado ao elemento.
       (e.g. "infinite")

O valor do atributo é uma lista de valores separados por ponto e vírgula. A interpretação de uma lista de horários de início é detalhada na especificação SMIL em "Avaliação de listas de horários de início e término". Cada valor individual pode ser um dos seguintes: <offset-value>, <syncbase-value>, <event-value>, <repeat-value>, <accessKey-value>, <wallclock-sync-value> ou a palavra-chave 'indefinite'.

func (*TagSvgSet) By 

func (e *TagSvgSet) By(by float64) (ref *TagSvgSet)

By

English: 

The by attribute specifies a relative offset value for an attribute that will be modified during an animation.

 Input:
   by: specifies a relative offset value for an attribute

The starting value for the attribute is either indicated by specifying it as value for the attribute given in the attributeName or the from attribute.

Português: 

O atributo by especifica um valor de deslocamento relativo para um atributo que será modificado durante uma
animação.

 Entrada:
   by: especifica um valor de deslocamento relativo para um atributo

O valor inicial para o atributo é indicado especificando-o como valor para o atributo fornecido no attributeName ou no atributo from.

func (*TagSvgSet) CalcMode 

func (e *TagSvgSet) CalcMode(value interface{}) (ref *TagSvgSet)

CalcMode

English: 

The calcMode attribute specifies the interpolation mode for the animation.

 Input:
   KSvgCalcModeDiscrete: This specifies that the animation function will jump from one value to the next without
     any interpolation.
   KSvgCalcModeLinear: Simple linear interpolation between values is used to calculate the animation function.
     Except for <animateMotion>, this is the default value.
   KSvgCalcModePaced: Defines interpolation to produce an even pace of change across the animation.
   KSvgCalcModeSpline: Interpolates from one value in the values list to the next according to a time function
     defined by a cubic Bézier spline. The points of the spline are defined in the keyTimes attribute, and the
     control points for each interval are defined in the keySplines attribute.

The default mode is linear, however if the attribute does not support linear interpolation (e.g. for strings), the calcMode attribute is ignored and discrete interpolation is used. 

Notes:
  Default value: KSvgCalcModePaced

Português: 

O atributo calcMode especifica o modo de interpolação para a animação.

 Entrada:
   KSvgCalcModeDiscrete: Isso especifica que a função de animação saltará de um valor para o próximo sem qualquer
     interpolação.
   KSvgCalcModeLinear: A interpolação linear simples entre valores é usada para calcular a função de animação.
     Exceto para <animateMotion>, este é o valor padrão.
   KSvgCalcModePaced: Define a interpolação para produzir um ritmo uniforme de mudança na animação.
   KSvgCalcModeSpline: Interpola de um valor na lista de valores para o próximo de acordo com uma função de tempo
     definida por uma spline de Bézier cúbica. Os pontos do spline são definidos no atributo keyTimes e os pontos
     de controle para cada intervalo são definidos no atributo keySplines.

O modo padrão é linear, no entanto, se o atributo não suportar interpolação linear (por exemplo, para strings), o atributo calcMode será ignorado e a interpolação discreta será usada. 

Notas:
  * Valor padrão: KSvgCalcModePaced

func (*TagSvgSet) Class 

func (e *TagSvgSet) Class(class string) (ref *TagSvgSet)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgSet) CreateElement 

func (e *TagSvgSet) CreateElement() (ref *TagSvgSet)

func (*TagSvgSet) Dur 

func (e *TagSvgSet) Dur(dur interface{}) (ref *TagSvgSet)

Dur

English: 

The dur attribute indicates the simple duration of an animation.

 Input:
   dur: indicates the simple duration of an animation.
     KSvgDur... (e.g. KSvgDurIndefinite)
     time.Duration (e.g. time.Second * 5)

 Notes:
   * The interpolation will not work if the simple duration is indefinite (although this may still be useful for
     <set> elements).

Português: 

O atributo dur indica a duração simples de uma animação.

 Entrada:
   dur: indica a duração simples de uma animação.
     KSvgDur... (ex. KSvgDurIndefinite)
     time.Duration (ex. time.Second * 5)

 Notas:
   * A interpolação não funcionará se a duração simples for indefinida (embora isso ainda possa ser útil para
     elementos <set>).

func (*TagSvgSet) End 

func (e *TagSvgSet) End(end interface{}) (ref *TagSvgSet)

End

English: 

The end attribute defines an end value for the animation that can constrain the active duration.

 Input:
   end: defines an end value for the animation
     offset-value: This value defines a clock-value that represents a point in time relative to the beginning of the
       SVG document (usually the load or DOMContentLoaded event). Negative values are valid.
       (e.g. time.Second*5 or "5s")
     syncbase-value: This value defines a syncbase and an optional offset from that syncbase. The element's
       animation start time is defined relative to the begin or active end of another animation.
       A valid syncbase-value consists of an ID reference to another animation element followed by a dot and either
       begin or end to identify whether to synchronize with the beginning or active end of the referenced animation
       element. An optional offset value as defined in <offset-value> can be appended.
       (e.g. "0s;third.end", "first.end" or "second.end")
     event-value: This value defines an event and an optional offset that determines the time at which the element's
       animation should begin. The animation start time is defined relative to the time that the specified event is
       fired.
       A valid event-value consists of an element ID followed by a dot and one of the supported events for that
       element. All valid events (not necessarily supported by all elements) are defined by the DOM and HTML
       specifications. Those are: 'focus', 'blur', 'focusin', 'focusout', 'activate', 'auxclick', 'click',
       'dblclick', 'mousedown', 'mouseenter', 'mouseleave', 'mousemove', 'mouseout', 'mouseover', 'mouseup',
       'wheel', 'beforeinput', 'input', 'keydown', 'keyup', 'compositionstart', 'compositionupdate',
       'compositionend', 'load', 'unload', 'abort', 'error', 'select', 'resize', 'scroll', 'beginEvent', 'endEvent',
       and 'repeatEvent'. An optional offset value as defined in <offset-value> can be appended.
       (e.g. "startButton.click")
     repeat-value: This value defines a qualified repeat event. The element animation start time is defined relative
       to the time that the repeat event is raised with the specified iteration value.
       A valid repeat value consists of an element ID followed by a dot and the function repeat() with an integer
       value specifying the number of repetitions as parameter. An optional offset value as defined in
       <offset-value> can be appended.
       (e.g. "0s;myLoop.end", "myLoop.begin", "myLoop.repeat(1)" or "myLoop.repeat(2)")
     accessKey-value: This value defines an access key that should trigger the animation. The element animation will
       begin when the user presses the specified key.
       A valid accessKey-value consists of the function accessKey() with the character to be input as parameter. An
       optional offset value as defined in <offset-value> can be appended.
       (e.g. "accessKey(s)")
     wallclock-sync-value: This value defines the animation start time as a real-world clock time.
       A valid wallclock-sync-value consists of the function wallclock() with a time value as parameter. The time
       syntax is based upon the syntax defined in ISO 8601.
       (e.g. time.Now() )
     indefinite: The begin of the animation will be determined by a beginElement() method call or a hyperlink
       targeted to the element.
       (e.g. "infinite")

Portuguese 

O atributo final define um valor final para a animação que pode restringir a duração ativa.

 Entrada:
   end: define um valor final para a animação
     offset-value: Esse valor define um valor de relógio que representa um ponto no tempo relativo ao início do
       documento SVG (geralmente o evento load ou DOMContentLoaded). Valores negativos são válidos.
       (e.g. time.Second*5 or "5s")
     syncbase-value: Esse valor define uma base de sincronização e um deslocamento opcional dessa base de
       sincronização. A hora de início da animação do elemento é definida em relação ao início ou fim ativo de outra
       animação.
       Um valor syncbase válido consiste em uma referência de ID para outro elemento de animação seguido por um
       ponto e um início ou fim para identificar se deve ser sincronizado com o início ou o final ativo do elemento
       de animação referenciado. Um valor de deslocamento opcional conforme definido em <offset-value> pode ser
       anexado.
       (e.g. "0s;third.end", "first.end" or "second.end")
     event-value: Esse valor define um evento e um deslocamento opcional que determina a hora em que a animação do
       elemento deve começar. A hora de início da animação é definida em relação à hora em que o evento especificado
       é acionado.
       Um valor de evento válido consiste em um ID de elemento seguido por um ponto e um dos eventos com suporte
       para esse elemento. Todos os eventos válidos (não necessariamente suportados por todos os elementos) são
       definidos pelas especificações DOM e HTML. Esses valores são: 'focus', 'blur', 'focusin', 'focusout',
       'activate', 'auxclick', 'click', 'dblclick', 'mousedown', 'mouseenter', 'mouseleave', 'mousemove',
       'mouseout', 'mouseover', 'mouseup', 'wheel', 'beforeinput', 'input', 'keydown', 'keyup', 'compositionstart',
       'compositionupdate', 'compositionend', 'load', 'unload', 'abort', 'error', 'select', 'resize', 'scroll',
       'beginEvent', 'endEvent', e 'repeatEvent'. Um valor de deslocamento opcional conforme definido em
       <offset-value> pode ser anexado.
       (e.g. "startButton.click")
     repeat-value: Esse valor define um evento de repetição qualificado. A hora de início da animação do elemento é
       definida em relação à hora em que o evento de repetição é gerado com o valor de iteração especificado.
       Um valor de repetição válido consiste em um ID de elemento seguido por um ponto e a função repeat() com um
       valor inteiro especificando o número de repetições como parâmetro. Um valor de deslocamento opcional conforme
       definido em <offset-value> pode ser anexado.
       (e.g. "0s;myLoop.end", "myLoop.begin", "myLoop.repeat(1)" or "myLoop.repeat(2)")
     accessKey-value: Este valor define uma chave de acesso que deve acionar a animação. A animação do elemento
       começará quando o usuário pressionar a tecla especificada.
       Um valor válido de accessKey consiste na função accessKey() com o caractere a ser inserido como parâmetro.
       Um valor de deslocamento opcional conforme definido em <valor de deslocamento> pode ser anexado.
       (e.g. "accessKey(s)")
     wallclock-sync-value: Esse valor define a hora de início da animação como uma hora do relógio do mundo real.
       Um valor wallclock-sync válido consiste na função wallclock() com um valor de tempo como parâmetro. A sintaxe
       de tempo é baseada na sintaxe definida na ISO 8601.
       (e.g. time.Now() )
     indefinite: O início da animação será determinado por uma chamada de método beginElement() ou um hiperlink
       direcionado ao elemento.
       (e.g. "infinite")

func (*TagSvgSet) Fill 

func (e *TagSvgSet) Fill(value interface{}) (ref *TagSvgSet)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgSet) From 

func (e *TagSvgSet) From(value interface{}) (ref *TagSvgSet)

From

English:

The from attribute indicates the initial value of the attribute that will be modified during the animation. 

Input:
  value: initial value of the attribute
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1),rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0%, 10%"
    []float64: []float64{0.0, 10.0} = "0, 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s, 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    any other type: interface{}

When used with the to attribute, the animation will change the modified attribute from the from value to the to value. When used with the by attribute, the animation will change the attribute relatively from the from value by the value specified in by.

Português:

O atributo from indica o valor inicial do atributo que será modificado durante a animação. 

Entrada:
  value: valor inicial do atributo
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1),rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0%, 10%"
    []float64: []float64{0.0, 10.0} = "0, 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s, 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    qualquer outro tipo: interface{}

Quando usado com o atributo to, a animação mudará o atributo modificado do valor from para o valor to. Quando usado com o atributo by, a animação mudará o atributo relativamente do valor from pelo valor especificado em by.

func (*TagSvgSet) Get 

func (e *TagSvgSet) Get() (el js.Value)

func (*TagSvgSet) HRef 

func (e *TagSvgSet) HRef(href string) (ref *TagSvgSet)

HRef

English: 

The href attribute defines a link to a resource as a reference URL. The exact meaning of that link depends on the
context of each element using it.

 Notes:
   * Specifications before SVG 2 defined an xlink:href attribute, which is now rendered obsolete by the href
     attribute.
     If you need to support earlier browser versions, the deprecated xlink:href attribute can be used as a fallback
     in addition to the href attribute, e.g. <use href="some-id" xlink:href="some-id x="5" y="5" />.

Português: 

O atributo href define um link para um recurso como um URL de referência. O significado exato desse link depende do
contexto de cada elemento que o utiliza.

 Notas:
   * As especificações anteriores ao SVG 2 definiam um atributo xlink:href, que agora se torna obsoleto pelo
     atributo href.
     Se você precisar oferecer suporte a versões anteriores do navegador, o atributo obsoleto xlink:href pode ser
     usado como um substituto além do atributo href, por exemplo,
     <use href="some-id" xlink:href="some-id x="5" y="5" />.

func (*TagSvgSet) Html 

func (e *TagSvgSet) Html(value string) (ref *TagSvgSet)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgSet) Id 

func (e *TagSvgSet) Id(id string) (ref *TagSvgSet)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgSet) Init 

func (e *TagSvgSet) Init() (ref *TagSvgSet)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgSet) KeySplines 

func (e *TagSvgSet) KeySplines(value interface{}) (ref *TagSvgSet)

KeySplines

English:

The keySplines attribute defines a set of Bézier curve control points associated with the keyTimes list, defining a cubic Bézier function that controls interval pacing.

This attribute is ignored unless the calcMode attribute is set to spline.

If there are any errors in the keySplines specification (bad values, too many or too few values), the animation will not occur.

Português:

O atributo keySplines define um conjunto de pontos de controle da curva Bézier associados à lista keyTimes, definindo uma função Bézier cúbica que controla o ritmo do intervalo.

Esse atributo é ignorado, a menos que o atributo calcMode seja definido como spline.

Se houver algum erro na especificação de keySplines (valores incorretos, muitos ou poucos valores), a animação não ocorrerá.

func (*TagSvgSet) KeyTimes 

func (e *TagSvgSet) KeyTimes(value interface{}) (ref *TagSvgSet)

KeyTimes

English:

The keyTimes attribute represents a list of time values used to control the pacing of the animation. 

Input:
  value: list of time values used to control
    []float64{0.0, 0.5, 1.0}: values="0; 0.5; 1"

Each time in the list corresponds to a value in the values attribute list, and defines when the value is used in the animation.

Each time value in the keyTimes list is specified as a floating point value between 0 and 1 (inclusive), representing a proportional offset into the duration of the animation element.

Português:

O atributo keyTimes representa uma lista de valores de tempo usados para controlar o ritmo da animação. 

Entrada:
  value: lista de valores de tempo usados para controle
    []float64{0.0, 0.5, 1.0}: values="0; 0.5; 1"

Cada vez na lista corresponde a um valor na lista de atributos de valores e define quando o valor é usado na animação.

Cada valor de tempo na lista keyTimes é especificado como um valor de ponto flutuante entre 0 e 1 (inclusive), representando um deslocamento proporcional à duração do elemento de animação.

func (*TagSvgSet) Lang 

func (e *TagSvgSet) Lang(value interface{}) (ref *TagSvgSet)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgSet) Max 

func (e *TagSvgSet) Max(value interface{}) (ref *TagSvgSet)

Max

English:

The max attribute specifies the maximum value of the active animation duration. 

Input:
  value: specifies the maximum value
    float32: 1.0 = "100%"
    time.Duration: 5*time.Second = "5s"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo max especifica o valor máximo da duração da animação ativa. 

Entrada:
  value: especifica o valor máximo
    float32: 1.0 = "100%"
    time.Duration: 5*time.Second = "5s"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgSet) Min 

func (e *TagSvgSet) Min(value interface{}) (ref *TagSvgSet)

Min

English:

The min attribute specifies the minimum value of the active animation duration. 

Input:
  value: specifies the minimum value
    float32: 1.0 = "100%"
    time.Duration: 5*time.Second = "5s"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo min especifica o valor mínimo da duração da animação ativa. 

Input:
  value: especifica o valor mínimo
    float32: 1.0 = "100%"
    time.Duration: 5*time.Second = "5s"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgSet) RepeatCount 

func (e *TagSvgSet) RepeatCount(value interface{}) (ref *TagSvgSet)

RepeatCount

English:

The repeatCount attribute indicates the number of times an animation will take place. 

Input:
  value: indicates the number of times an animation will take place
    int: number of times
    const: KSvgDurIndefinite
    any other type: interface{}

Português:

O atributo repeatCount indica o número de vezes que uma animação ocorrerá. 

Input:
  value: indica o número de vezes que uma animação ocorrerá
    int: número de vezes
    const: KSvgDurIndefinite
    qualquer outro tipo: interface{}

func (*TagSvgSet) RepeatDur 

func (e *TagSvgSet) RepeatDur(value interface{}) (ref *TagSvgSet)

RepeatDur

English:

The repeatDur attribute specifies the total duration for repeating an animation. 

Input:
  value: specifies the total duration for repeating an animation
    string: "5s"
    time.Duration: 5*time.Second = "5s"
    const: KSvgDurIndefinite
    any other type: interface{}

Português:

O atributo repeatDur especifica a duração total para repetir uma animação. 

Entrada:
  value: especifica a duração total para repetir uma animação
    string: "5s"
    time.Duration: 5*time.Second = "5s"
    const: KSvgDurIndefinite
    qualquer outro tipo: interface{}

func (*TagSvgSet) Restart 

func (e *TagSvgSet) Restart(value interface{}) (ref *TagSvgSet)

Restart

English:

The restart attribute specifies whether or not an animation can restart. 

Input:
  value: especifica se uma animação pode ou não reiniciar
    const: KSvgAnimationRestart... (e.g. KSvgAnimationRestartAlways)
    any other type: interface{}

Português:

O atributo restart especifica se uma animação pode ou não reiniciar. 

Entrada:
  value: especifica se uma animação pode ou não reiniciar
    const: KSvgAnimationRestart... (ex. KSvgAnimationRestartAlways)
    qualquer outro tipo: interface{}

func (*TagSvgSet) Style 

func (e *TagSvgSet) Style(value string) (ref *TagSvgSet)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgSet) Tabindex 

func (e *TagSvgSet) Tabindex(value int) (ref *TagSvgSet)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgSet) Text 

func (e *TagSvgSet) Text(value string) (ref *TagSvgSet)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgSet) To 

func (e *TagSvgSet) To(value interface{}) (ref *TagSvgSet)

To

English:

The to attribute indicates the final value of the attribute that will be modified during the animation. 

Input:
  value: final value of the attribute
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1),rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0%, 10%"
    []float64: []float64{0.0, 10.0} = "0, 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s, 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    any other type: interface{}

The value of the attribute will change between the from attribute value and this value.

Português:

O atributo to indica o valor final do atributo que será modificado durante a animação. 

Entrada:
  value: valor final do atributo
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1),rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0%, 10%"
    []float64: []float64{0.0, 10.0} = "0, 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s, 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    qualquer outro tipo: interface{}

O valor do atributo mudará entre o valor do atributo from e este valor.

func (*TagSvgSet) Values 

func (e *TagSvgSet) Values(value interface{}) (ref *TagSvgSet)

Values

English:

The values attribute has different meanings, depending upon the context where it's used, either it defines a sequence of values used over the course of an animation, or it's a list of numbers for a color matrix, which is interpreted differently depending on the type of color change to be performed. 

Input:
  value: list of values
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1),rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0%, 10%"
    []float64: []float64{0.0, 10.0} = "0, 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s, 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    any other type: interface{}

Português:

O atributo values tem significados diferentes, dependendo do contexto em que é usado, ou define uma sequência de valores usados ao longo de uma animação, ou é uma lista de números para uma matriz de cores, que é interpretada de forma diferente dependendo do tipo de mudança de cor a ser executada. 

Input:
  value: lista de valores
    []color.RGBA{factoryColor.NewBlack(),factoryColor.NewRed()} = "rgba(0,0,0,1),rgba(255,0,0,1)"
    []float32: []float64{0.0, 0.1} = "0%, 10%"
    []float64: []float64{0.0, 10.0} = "0, 10"
    []time.Duration: []time.Duration{0, time.Second} = "0s, 1s"
    time.Duration: time.Second = "1s"
    float32: 0.1 = "10%"
    float64: 10.0 = "10"
    color.RGBA: factoryColor.NewRed() = "rgba(255,0,0,1)"
    any other type: interface{}

func (*TagSvgSet) XLinkHRef deprecated 

func (e *TagSvgSet) XLinkHRef(value interface{}) (ref *TagSvgSet)

XLinkHRef

English:

Deprecated: use HRef() function

The xlink:href attribute defines a reference to a resource as a reference IRI. The exact meaning of that link depends on the context of each element using it. 

Notes:
  * SVG 2 removed the need for the xlink namespace, so instead of xlink:href you should use href. If you need to
    support earlier browser versions, the deprecated xlink:href attribute can be used as a fallback in addition to
    the href attribute, e.g. <use href="some-id" xlink:href="some-id" x="5" y="5" />.

Português:

Obsoleto: use a função HRef()

O atributo xlink:href define uma referência a um recurso como um IRI de referência. O significado exato desse link depende do contexto de cada elemento que o utiliza. 

Notas:
  * O SVG 2 removeu a necessidade do namespace xlink, então ao invés de xlink:href você deve usar href. Se você
    precisar oferecer suporte a versões anteriores do navegador, o atributo obsoleto xlink:href pode ser usado como
    um substituto além do atributo href, por exemplo, <use href="some-id" xlink:href="some-id" x="5" y="5" >.

func (*TagSvgSet) XmlLang 

func (e *TagSvgSet) XmlLang(value interface{}) (ref *TagSvgSet)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

type TagSvgStop 

type TagSvgStop struct {
	// contains filtered or unexported fields
}

TagSvgStop

English:

The SVG <stop> element defines a color and its position to use on a gradient. This element is always a child of a <linearGradient> or <radialGradient> element.

Português:

O elemento SVG <stop> define uma cor e sua posição para usar em um gradiente. Este elemento é sempre um filho de um elemento <linearGradient> ou <radialGradient>.

func (*TagSvgStop) Append 

func (e *TagSvgStop) Append(elements ...Compatible) (ref *TagSvgStop)

func (*TagSvgStop) AppendById 

func (e *TagSvgStop) AppendById(appendId string) (ref *TagSvgStop)

func (*TagSvgStop) AppendToElement 

func (e *TagSvgStop) AppendToElement(el js.Value) (ref *TagSvgStop)

func (*TagSvgStop) AppendToStage 

func (e *TagSvgStop) AppendToStage() (ref *TagSvgStop)

func (*TagSvgStop) BaselineShift 

func (e *TagSvgStop) BaselineShift(baselineShift interface{}) (ref *TagSvgStop)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgStop) Class 

func (e *TagSvgStop) Class(class string) (ref *TagSvgStop)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgStop) ClipPath 

func (e *TagSvgStop) ClipPath(clipPath string) (ref *TagSvgStop)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgStop) ClipRule 

func (e *TagSvgStop) ClipRule(value interface{}) (ref *TagSvgStop)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgStop) Color 

func (e *TagSvgStop) Color(value interface{}) (ref *TagSvgStop)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgStop) ColorInterpolation 

func (e *TagSvgStop) ColorInterpolation(value interface{}) (ref *TagSvgStop)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgStop) ColorInterpolationFilters 

func (e *TagSvgStop) ColorInterpolationFilters(value interface{}) (ref *TagSvgStop)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgStop) CreateElement 

func (e *TagSvgStop) CreateElement() (ref *TagSvgStop)

func (*TagSvgStop) Cursor 

func (e *TagSvgStop) Cursor(cursor SvgCursor) (ref *TagSvgStop)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgStop) Direction 

func (e *TagSvgStop) Direction(direction SvgDirection) (ref *TagSvgStop)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgStop) Display 

func (e *TagSvgStop) Display(value interface{}) (ref *TagSvgStop)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgStop) DominantBaseline 

func (e *TagSvgStop) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgStop)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgStop) Fill 

func (e *TagSvgStop) Fill(value interface{}) (ref *TagSvgStop)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgStop) FillOpacity 

func (e *TagSvgStop) FillOpacity(value interface{}) (ref *TagSvgStop)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgStop) FillRule 

func (e *TagSvgStop) FillRule(fillRule SvgFillRule) (ref *TagSvgStop)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgStop) Filter 

func (e *TagSvgStop) Filter(filter string) (ref *TagSvgStop)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgStop) FloodColor 

func (e *TagSvgStop) FloodColor(floodColor interface{}) (ref *TagSvgStop)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgStop) FloodOpacity 

func (e *TagSvgStop) FloodOpacity(floodOpacity float64) (ref *TagSvgStop)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgStop) FontFamily 

func (e *TagSvgStop) FontFamily(fontFamily string) (ref *TagSvgStop)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgStop) FontSize 

func (e *TagSvgStop) FontSize(fontSize interface{}) (ref *TagSvgStop)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgStop) FontSizeAdjust 

func (e *TagSvgStop) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgStop)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgStop) FontStretch 

func (e *TagSvgStop) FontStretch(fontStretch interface{}) (ref *TagSvgStop)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgStop) FontStyle 

func (e *TagSvgStop) FontStyle(fontStyle FontStyleRule) (ref *TagSvgStop)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgStop) FontVariant 

func (e *TagSvgStop) FontVariant(value interface{}) (ref *TagSvgStop)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgStop) FontWeight 

func (e *TagSvgStop) FontWeight(value interface{}) (ref *TagSvgStop)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgStop) Get 

func (e *TagSvgStop) Get() (el js.Value)

func (*TagSvgStop) Html 

func (e *TagSvgStop) Html(value string) (ref *TagSvgStop)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgStop) Id 

func (e *TagSvgStop) Id(id string) (ref *TagSvgStop)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgStop) ImageRendering 

func (e *TagSvgStop) ImageRendering(imageRendering string) (ref *TagSvgStop)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgStop) Init 

func (e *TagSvgStop) Init() (ref *TagSvgStop)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgStop) Lang 

func (e *TagSvgStop) Lang(value interface{}) (ref *TagSvgStop)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgStop) LetterSpacing 

func (e *TagSvgStop) LetterSpacing(value float64) (ref *TagSvgStop)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgStop) LightingColor 

func (e *TagSvgStop) LightingColor(value interface{}) (ref *TagSvgStop)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgStop) MarkerEnd 

func (e *TagSvgStop) MarkerEnd(value interface{}) (ref *TagSvgStop)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgStop) MarkerMid 

func (e *TagSvgStop) MarkerMid(value interface{}) (ref *TagSvgStop)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgStop) MarkerStart 

func (e *TagSvgStop) MarkerStart(value interface{}) (ref *TagSvgStop)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgStop) Mask 

func (e *TagSvgStop) Mask(value interface{}) (ref *TagSvgStop)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgStop) Offset 

func (e *TagSvgStop) Offset(value interface{}) (ref *TagSvgStop)

Offset

English:

This attribute defines where the gradient stop is placed along the gradient vector.

Português:

Este atributo define onde a parada de gradiente é colocada ao longo do vetor de gradiente.

func (*TagSvgStop) Opacity 

func (e *TagSvgStop) Opacity(value interface{}) (ref *TagSvgStop)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgStop) Overflow 

func (e *TagSvgStop) Overflow(value interface{}) (ref *TagSvgStop)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgStop) PointerEvents 

func (e *TagSvgStop) PointerEvents(value interface{}) (ref *TagSvgStop)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgStop) ShapeRendering 

func (e *TagSvgStop) ShapeRendering(value interface{}) (ref *TagSvgStop)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgStop) StopColor 

func (e *TagSvgStop) StopColor(value interface{}) (ref *TagSvgStop)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgStop) StopOpacity 

func (e *TagSvgStop) StopOpacity(value interface{}) (ref *TagSvgStop)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgStop) Stroke 

func (e *TagSvgStop) Stroke(value interface{}) (ref *TagSvgStop)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgStop) StrokeDasharray 

func (e *TagSvgStop) StrokeDasharray(value interface{}) (ref *TagSvgStop)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgStop) StrokeLineCap 

func (e *TagSvgStop) StrokeLineCap(value interface{}) (ref *TagSvgStop)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgStop) StrokeLineJoin 

func (e *TagSvgStop) StrokeLineJoin(value interface{}) (ref *TagSvgStop)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgStop) StrokeMiterLimit 

func (e *TagSvgStop) StrokeMiterLimit(value float64) (ref *TagSvgStop)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgStop) StrokeOpacity 

func (e *TagSvgStop) StrokeOpacity(value interface{}) (ref *TagSvgStop)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgStop) StrokeWidth 

func (e *TagSvgStop) StrokeWidth(value interface{}) (ref *TagSvgStop)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgStop) Style 

func (e *TagSvgStop) Style(value string) (ref *TagSvgStop)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgStop) Tabindex 

func (e *TagSvgStop) Tabindex(value int) (ref *TagSvgStop)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgStop) Text 

func (e *TagSvgStop) Text(value string) (ref *TagSvgStop)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgStop) TextAnchor 

func (e *TagSvgStop) TextAnchor(value interface{}) (ref *TagSvgStop)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgStop) TextDecoration 

func (e *TagSvgStop) TextDecoration(value interface{}) (ref *TagSvgStop)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgStop) TextRendering 

func (e *TagSvgStop) TextRendering(value interface{}) (ref *TagSvgStop)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgStop) Transform 

func (e *TagSvgStop) Transform(value interface{}) (ref *TagSvgStop)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgStop) UnicodeBidi 

func (e *TagSvgStop) UnicodeBidi(value interface{}) (ref *TagSvgStop)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgStop) VectorEffect 

func (e *TagSvgStop) VectorEffect(value interface{}) (ref *TagSvgStop)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgStop) Visibility 

func (e *TagSvgStop) Visibility(value interface{}) (ref *TagSvgStop)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgStop) WordSpacing 

func (e *TagSvgStop) WordSpacing(value interface{}) (ref *TagSvgStop)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgStop) WritingMode 

func (e *TagSvgStop) WritingMode(value interface{}) (ref *TagSvgStop)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgStop) XmlLang 

func (e *TagSvgStop) XmlLang(value interface{}) (ref *TagSvgStop)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

type TagSvgStyle 

type TagSvgStyle struct {
	// contains filtered or unexported fields
}

TagSvgStyle

English:

The SVG <style> element allows style sheets to be embedded directly within SVG content. 

Notes:
  * SVG's style element has the same attributes as the corresponding element in HTML
    (see HTML's <style> element).

Português:

O elemento SVG <style> permite que as folhas de estilo sejam incorporadas diretamente no conteúdo SVG. 

Notas:
  * O elemento de estilo SVG tem os mesmos atributos que o elemento correspondente em HTML
    (definir elemento HTML <style>).

func (*TagSvgStyle) Append 

func (e *TagSvgStyle) Append(elements ...Compatible) (ref *TagSvgStyle)

func (*TagSvgStyle) AppendById 

func (e *TagSvgStyle) AppendById(appendId string) (ref *TagSvgStyle)

func (*TagSvgStyle) AppendToElement 

func (e *TagSvgStyle) AppendToElement(el js.Value) (ref *TagSvgStyle)

func (*TagSvgStyle) AppendToStage 

func (e *TagSvgStyle) AppendToStage() (ref *TagSvgStyle)

func (*TagSvgStyle) Class 

func (e *TagSvgStyle) Class(class string) (ref *TagSvgStyle)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgStyle) CreateElement 

func (e *TagSvgStyle) CreateElement() (ref *TagSvgStyle)

func (*TagSvgStyle) Get 

func (e *TagSvgStyle) Get() (el js.Value)

func (*TagSvgStyle) Html 

func (e *TagSvgStyle) Html(value string) (ref *TagSvgStyle)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgStyle) Id 

func (e *TagSvgStyle) Id(id string) (ref *TagSvgStyle)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgStyle) Init 

func (e *TagSvgStyle) Init() (ref *TagSvgStyle)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgStyle) Lang 

func (e *TagSvgStyle) Lang(value interface{}) (ref *TagSvgStyle)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgStyle) Media 

func (e *TagSvgStyle) Media(value interface{}) (ref *TagSvgStyle)

Media

English:

The media attribute specifies a media query that must be matched for a style sheet to apply.

Português:

O atributo de mídia especifica uma consulta de mídia que deve ser correspondida para que uma folha de estilo seja aplicada.

func (*TagSvgStyle) Style 

func (e *TagSvgStyle) Style(value string) (ref *TagSvgStyle)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgStyle) Tabindex 

func (e *TagSvgStyle) Tabindex(value int) (ref *TagSvgStyle)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgStyle) Text 

func (e *TagSvgStyle) Text(value string) (ref *TagSvgStyle)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgStyle) Type 

func (e *TagSvgStyle) Type(value interface{}) (ref *TagSvgStyle)

Type

English:

Defines the content type of the element 

Input:
  value: content type of the element
    any other type: interface{}

Português:

Define o tipo de conteúdo do elemento. 

Input:
  value: tipo de conteúdo do elemento.
    qualquer outro tipo: interface{}

func (*TagSvgStyle) XmlLang 

func (e *TagSvgStyle) XmlLang(value interface{}) (ref *TagSvgStyle)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

type TagSvgSwitch 

type TagSvgSwitch struct {
	// contains filtered or unexported fields
}

TagSvgSwitch

English:

The <switch> SVG element evaluates any requiredFeatures, requiredExtensions and systemLanguage attributes on its direct child elements in order, and then renders the first child where these attributes evaluate to true.

Other direct children will be bypassed and therefore not rendered. If a child element is a container element, like <g>, then its subtree is also processed/rendered or bypassed/not rendered. 

Notes:
  * The display and visibility properties have no effect on <switch> element processing.
    In particular, setting display:none on a child has no effect on the true/false testing for <switch> processing.

Português:

O elemento SVG <switch> avalia todos os atributos requiredFeatures, requiredExtensions e systemLanguage em seus elementos filho diretos em ordem e, em seguida, renderiza o primeiro filho em que esses atributos são avaliados como true.

Outros filhos diretos serão ignorados e, portanto, não renderizados. Se um elemento filho for um elemento contêiner, como <g>, sua subárvore também será processada, renderizada ou ignorada, não renderizada. 

Notas:
  * As propriedades de exibição e visibilidade não têm efeito no processamento do elemento <switch>.
    Em particular, configurar display:none em um filho não tem efeito no teste truefalse para processamento de <switch>.

func (*TagSvgSwitch) Append 

func (e *TagSvgSwitch) Append(elements ...Compatible) (ref *TagSvgSwitch)

func (*TagSvgSwitch) AppendById 

func (e *TagSvgSwitch) AppendById(appendId string) (ref *TagSvgSwitch)

func (*TagSvgSwitch) AppendToElement 

func (e *TagSvgSwitch) AppendToElement(el js.Value) (ref *TagSvgSwitch)

func (*TagSvgSwitch) AppendToStage 

func (e *TagSvgSwitch) AppendToStage() (ref *TagSvgSwitch)

func (*TagSvgSwitch) BaselineShift 

func (e *TagSvgSwitch) BaselineShift(baselineShift interface{}) (ref *TagSvgSwitch)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgSwitch) Class 

func (e *TagSvgSwitch) Class(class string) (ref *TagSvgSwitch)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgSwitch) ClipPath 

func (e *TagSvgSwitch) ClipPath(clipPath string) (ref *TagSvgSwitch)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgSwitch) ClipRule 

func (e *TagSvgSwitch) ClipRule(value interface{}) (ref *TagSvgSwitch)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgSwitch) Color 

func (e *TagSvgSwitch) Color(value interface{}) (ref *TagSvgSwitch)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgSwitch) ColorInterpolation 

func (e *TagSvgSwitch) ColorInterpolation(value interface{}) (ref *TagSvgSwitch)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgSwitch) ColorInterpolationFilters 

func (e *TagSvgSwitch) ColorInterpolationFilters(value interface{}) (ref *TagSvgSwitch)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgSwitch) CreateElement 

func (e *TagSvgSwitch) CreateElement() (ref *TagSvgSwitch)

func (*TagSvgSwitch) Cursor 

func (e *TagSvgSwitch) Cursor(cursor SvgCursor) (ref *TagSvgSwitch)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgSwitch) Direction 

func (e *TagSvgSwitch) Direction(direction SvgDirection) (ref *TagSvgSwitch)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgSwitch) Display 

func (e *TagSvgSwitch) Display(value interface{}) (ref *TagSvgSwitch)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgSwitch) DominantBaseline 

func (e *TagSvgSwitch) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgSwitch)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgSwitch) Fill 

func (e *TagSvgSwitch) Fill(value interface{}) (ref *TagSvgSwitch)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgSwitch) FillOpacity 

func (e *TagSvgSwitch) FillOpacity(value interface{}) (ref *TagSvgSwitch)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgSwitch) FillRule 

func (e *TagSvgSwitch) FillRule(fillRule SvgFillRule) (ref *TagSvgSwitch)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgSwitch) Filter 

func (e *TagSvgSwitch) Filter(filter string) (ref *TagSvgSwitch)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgSwitch) FloodColor 

func (e *TagSvgSwitch) FloodColor(floodColor interface{}) (ref *TagSvgSwitch)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgSwitch) FloodOpacity 

func (e *TagSvgSwitch) FloodOpacity(floodOpacity float64) (ref *TagSvgSwitch)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgSwitch) FontFamily 

func (e *TagSvgSwitch) FontFamily(fontFamily string) (ref *TagSvgSwitch)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgSwitch) FontSize 

func (e *TagSvgSwitch) FontSize(fontSize interface{}) (ref *TagSvgSwitch)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgSwitch) FontSizeAdjust 

func (e *TagSvgSwitch) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgSwitch)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgSwitch) FontStretch 

func (e *TagSvgSwitch) FontStretch(fontStretch interface{}) (ref *TagSvgSwitch)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgSwitch) FontStyle 

func (e *TagSvgSwitch) FontStyle(fontStyle FontStyleRule) (ref *TagSvgSwitch)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgSwitch) FontVariant 

func (e *TagSvgSwitch) FontVariant(value interface{}) (ref *TagSvgSwitch)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgSwitch) FontWeight 

func (e *TagSvgSwitch) FontWeight(value interface{}) (ref *TagSvgSwitch)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgSwitch) Get 

func (e *TagSvgSwitch) Get() (el js.Value)

func (*TagSvgSwitch) Html 

func (e *TagSvgSwitch) Html(value string) (ref *TagSvgSwitch)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgSwitch) Id 

func (e *TagSvgSwitch) Id(id string) (ref *TagSvgSwitch)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgSwitch) ImageRendering 

func (e *TagSvgSwitch) ImageRendering(imageRendering string) (ref *TagSvgSwitch)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgSwitch) Init 

func (e *TagSvgSwitch) Init() (ref *TagSvgSwitch)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgSwitch) Lang 

func (e *TagSvgSwitch) Lang(value interface{}) (ref *TagSvgSwitch)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgSwitch) LetterSpacing 

func (e *TagSvgSwitch) LetterSpacing(value float64) (ref *TagSvgSwitch)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgSwitch) LightingColor 

func (e *TagSvgSwitch) LightingColor(value interface{}) (ref *TagSvgSwitch)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgSwitch) MarkerEnd 

func (e *TagSvgSwitch) MarkerEnd(value interface{}) (ref *TagSvgSwitch)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgSwitch) MarkerMid 

func (e *TagSvgSwitch) MarkerMid(value interface{}) (ref *TagSvgSwitch)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgSwitch) MarkerStart 

func (e *TagSvgSwitch) MarkerStart(value interface{}) (ref *TagSvgSwitch)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgSwitch) Mask 

func (e *TagSvgSwitch) Mask(value interface{}) (ref *TagSvgSwitch)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgSwitch) Opacity 

func (e *TagSvgSwitch) Opacity(value interface{}) (ref *TagSvgSwitch)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgSwitch) Overflow 

func (e *TagSvgSwitch) Overflow(value interface{}) (ref *TagSvgSwitch)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgSwitch) PointerEvents 

func (e *TagSvgSwitch) PointerEvents(value interface{}) (ref *TagSvgSwitch)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgSwitch) ShapeRendering 

func (e *TagSvgSwitch) ShapeRendering(value interface{}) (ref *TagSvgSwitch)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgSwitch) StopColor 

func (e *TagSvgSwitch) StopColor(value interface{}) (ref *TagSvgSwitch)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgSwitch) StopOpacity 

func (e *TagSvgSwitch) StopOpacity(value interface{}) (ref *TagSvgSwitch)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgSwitch) Stroke 

func (e *TagSvgSwitch) Stroke(value interface{}) (ref *TagSvgSwitch)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgSwitch) StrokeDasharray 

func (e *TagSvgSwitch) StrokeDasharray(value interface{}) (ref *TagSvgSwitch)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgSwitch) StrokeLineCap 

func (e *TagSvgSwitch) StrokeLineCap(value interface{}) (ref *TagSvgSwitch)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgSwitch) StrokeLineJoin 

func (e *TagSvgSwitch) StrokeLineJoin(value interface{}) (ref *TagSvgSwitch)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgSwitch) StrokeMiterLimit 

func (e *TagSvgSwitch) StrokeMiterLimit(value float64) (ref *TagSvgSwitch)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgSwitch) StrokeOpacity 

func (e *TagSvgSwitch) StrokeOpacity(value interface{}) (ref *TagSvgSwitch)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgSwitch) StrokeWidth 

func (e *TagSvgSwitch) StrokeWidth(value interface{}) (ref *TagSvgSwitch)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgSwitch) Style 

func (e *TagSvgSwitch) Style(value string) (ref *TagSvgSwitch)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgSwitch) SystemLanguage 

func (e *TagSvgSwitch) SystemLanguage(value interface{}) (ref *TagSvgSwitch)

SystemLanguage

English:

The systemLanguage attribute represents a list of supported language tags. This list is matched against the language defined in the user preferences.

Português:

O atributo systemLanguage representa uma lista de tags de idioma com suporte. Esta lista é comparada com o idioma definido nas preferências do usuário.

func (*TagSvgSwitch) Tabindex 

func (e *TagSvgSwitch) Tabindex(value int) (ref *TagSvgSwitch)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgSwitch) Text 

func (e *TagSvgSwitch) Text(value string) (ref *TagSvgSwitch)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgSwitch) TextAnchor 

func (e *TagSvgSwitch) TextAnchor(value interface{}) (ref *TagSvgSwitch)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgSwitch) TextDecoration 

func (e *TagSvgSwitch) TextDecoration(value interface{}) (ref *TagSvgSwitch)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgSwitch) TextRendering 

func (e *TagSvgSwitch) TextRendering(value interface{}) (ref *TagSvgSwitch)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgSwitch) Transform 

func (e *TagSvgSwitch) Transform(value interface{}) (ref *TagSvgSwitch)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgSwitch) UnicodeBidi 

func (e *TagSvgSwitch) UnicodeBidi(value interface{}) (ref *TagSvgSwitch)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgSwitch) VectorEffect 

func (e *TagSvgSwitch) VectorEffect(value interface{}) (ref *TagSvgSwitch)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgSwitch) Visibility 

func (e *TagSvgSwitch) Visibility(value interface{}) (ref *TagSvgSwitch)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgSwitch) WordSpacing 

func (e *TagSvgSwitch) WordSpacing(value interface{}) (ref *TagSvgSwitch)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgSwitch) WritingMode 

func (e *TagSvgSwitch) WritingMode(value interface{}) (ref *TagSvgSwitch)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgSwitch) XmlLang 

func (e *TagSvgSwitch) XmlLang(value interface{}) (ref *TagSvgSwitch)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

type TagSvgSymbol 

type TagSvgSymbol struct {
	// contains filtered or unexported fields
}

TagSvgSymbol

English:

The <symbol> element is used to define graphical template objects which can be instantiated by a <use> element.

The use of <symbol> elements for graphics that are used multiple times in the same document adds structure and semantics.

Documents that are rich in structure may be rendered graphically, as speech, or as Braille, and thus promote accessibility.

Português:

O elemento <symbol> é usado para definir objetos de template gráficos que podem ser instanciados por um elemento <use>.

O uso de elementos <symbol> para gráficos que são usados várias vezes no mesmo documento adiciona estrutura e semântica.

Documentos ricos em estrutura podem ser renderizados graficamente, como fala, ou como Braille, promovendo assim a acessibilidade.

func (*TagSvgSymbol) Append 

func (e *TagSvgSymbol) Append(elements ...Compatible) (ref *TagSvgSymbol)

func (*TagSvgSymbol) AppendById 

func (e *TagSvgSymbol) AppendById(appendId string) (ref *TagSvgSymbol)

func (*TagSvgSymbol) AppendToElement 

func (e *TagSvgSymbol) AppendToElement(el js.Value) (ref *TagSvgSymbol)

func (*TagSvgSymbol) AppendToStage 

func (e *TagSvgSymbol) AppendToStage() (ref *TagSvgSymbol)

func (*TagSvgSymbol) BaselineShift 

func (e *TagSvgSymbol) BaselineShift(baselineShift interface{}) (ref *TagSvgSymbol)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgSymbol) Class 

func (e *TagSvgSymbol) Class(class string) (ref *TagSvgSymbol)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgSymbol) ClipPath 

func (e *TagSvgSymbol) ClipPath(clipPath string) (ref *TagSvgSymbol)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgSymbol) ClipRule 

func (e *TagSvgSymbol) ClipRule(value interface{}) (ref *TagSvgSymbol)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgSymbol) Color 

func (e *TagSvgSymbol) Color(value interface{}) (ref *TagSvgSymbol)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgSymbol) ColorInterpolation 

func (e *TagSvgSymbol) ColorInterpolation(value interface{}) (ref *TagSvgSymbol)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgSymbol) ColorInterpolationFilters 

func (e *TagSvgSymbol) ColorInterpolationFilters(value interface{}) (ref *TagSvgSymbol)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgSymbol) CreateElement 

func (e *TagSvgSymbol) CreateElement() (ref *TagSvgSymbol)

func (*TagSvgSymbol) Cursor 

func (e *TagSvgSymbol) Cursor(cursor SvgCursor) (ref *TagSvgSymbol)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgSymbol) Direction 

func (e *TagSvgSymbol) Direction(direction SvgDirection) (ref *TagSvgSymbol)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgSymbol) Display 

func (e *TagSvgSymbol) Display(value interface{}) (ref *TagSvgSymbol)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgSymbol) DominantBaseline 

func (e *TagSvgSymbol) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgSymbol)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgSymbol) Fill 

func (e *TagSvgSymbol) Fill(value interface{}) (ref *TagSvgSymbol)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgSymbol) FillOpacity 

func (e *TagSvgSymbol) FillOpacity(value interface{}) (ref *TagSvgSymbol)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgSymbol) FillRule 

func (e *TagSvgSymbol) FillRule(fillRule SvgFillRule) (ref *TagSvgSymbol)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgSymbol) Filter 

func (e *TagSvgSymbol) Filter(filter string) (ref *TagSvgSymbol)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgSymbol) FloodColor 

func (e *TagSvgSymbol) FloodColor(floodColor interface{}) (ref *TagSvgSymbol)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgSymbol) FloodOpacity 

func (e *TagSvgSymbol) FloodOpacity(floodOpacity float64) (ref *TagSvgSymbol)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgSymbol) FontFamily 

func (e *TagSvgSymbol) FontFamily(fontFamily string) (ref *TagSvgSymbol)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgSymbol) FontSize 

func (e *TagSvgSymbol) FontSize(fontSize interface{}) (ref *TagSvgSymbol)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgSymbol) FontSizeAdjust 

func (e *TagSvgSymbol) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgSymbol)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgSymbol) FontStretch 

func (e *TagSvgSymbol) FontStretch(fontStretch interface{}) (ref *TagSvgSymbol)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgSymbol) FontStyle 

func (e *TagSvgSymbol) FontStyle(fontStyle FontStyleRule) (ref *TagSvgSymbol)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgSymbol) FontVariant 

func (e *TagSvgSymbol) FontVariant(value interface{}) (ref *TagSvgSymbol)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgSymbol) FontWeight 

func (e *TagSvgSymbol) FontWeight(value interface{}) (ref *TagSvgSymbol)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgSymbol) Get 

func (e *TagSvgSymbol) Get() (el js.Value)

func (*TagSvgSymbol) Height 

func (e *TagSvgSymbol) Height(height interface{}) (ref *TagSvgSymbol)

Height

English: 

The height attribute defines the vertical length of an element in the user coordinate system.
     float32: 1.0 = "100%"
     any other type: interface{}

Português: 

O atributo height define o comprimento vertical de um elemento no sistema de coordenadas do usuário.
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

func (*TagSvgSymbol) Html 

func (e *TagSvgSymbol) Html(value string) (ref *TagSvgSymbol)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgSymbol) Id 

func (e *TagSvgSymbol) Id(id string) (ref *TagSvgSymbol)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgSymbol) ImageRendering 

func (e *TagSvgSymbol) ImageRendering(imageRendering string) (ref *TagSvgSymbol)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgSymbol) Init 

func (e *TagSvgSymbol) Init() (ref *TagSvgSymbol)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgSymbol) Lang 

func (e *TagSvgSymbol) Lang(value interface{}) (ref *TagSvgSymbol)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgSymbol) LetterSpacing 

func (e *TagSvgSymbol) LetterSpacing(value float64) (ref *TagSvgSymbol)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgSymbol) LightingColor 

func (e *TagSvgSymbol) LightingColor(value interface{}) (ref *TagSvgSymbol)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgSymbol) MarkerEnd 

func (e *TagSvgSymbol) MarkerEnd(value interface{}) (ref *TagSvgSymbol)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgSymbol) MarkerMid 

func (e *TagSvgSymbol) MarkerMid(value interface{}) (ref *TagSvgSymbol)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgSymbol) MarkerStart 

func (e *TagSvgSymbol) MarkerStart(value interface{}) (ref *TagSvgSymbol)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgSymbol) Mask 

func (e *TagSvgSymbol) Mask(value interface{}) (ref *TagSvgSymbol)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgSymbol) Opacity 

func (e *TagSvgSymbol) Opacity(value interface{}) (ref *TagSvgSymbol)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgSymbol) Overflow 

func (e *TagSvgSymbol) Overflow(value interface{}) (ref *TagSvgSymbol)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgSymbol) PointerEvents 

func (e *TagSvgSymbol) PointerEvents(value interface{}) (ref *TagSvgSymbol)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgSymbol) PreserveAspectRatio 

func (e *TagSvgSymbol) PreserveAspectRatio(ratio, meet interface{}) (ref *TagSvgSymbol)

PreserveAspectRatio

English: 

The preserveAspectRatio attribute indicates how an element with a viewBox providing a given aspect ratio must fit
into a viewport with a different aspect ratio.

 Input:
   ratio: Indicates how an element with a viewBox providing a given aspect ratio.
     const: KRatio... (e.g. KRatioXMinYMin)
     any other type: interface{}
   meet: The meet or slice reference
     const: KMeetOrSliceReference... (e.g. KMeetOrSliceReferenceSlice)
     any other type: interface{}

Because the aspect ratio of an SVG image is defined by the viewBox attribute, if this attribute isn't set, the preserveAspectRatio attribute has no effect (with one exception, the <image> element, as described below).

Português: 

O atributo preserveAspectRatio indica como um elemento com uma viewBox fornecendo uma determinada proporção deve
caber em uma viewport com uma proporção diferente.

 Input:
   ratio: Indica como um elemento com uma viewBox fornece uma determinada proporção.
     const: KRatio... (ex. KRatioXMinYMin)
     qualquer outro tipo: interface{}
   meet: A referência de encontro ou fatia
     const: KMeetOrSliceReference... (ex. KMeetOrSliceReferenceSlice)
     qualquer outro tipo: interface{}

Como a proporção de uma imagem SVG é definida pelo atributo viewBox, se esse atributo não estiver definido, o atributo preserveAspectRatio não terá efeito (com uma exceção, o elemento <image>, conforme descrito abaixo).

func (*TagSvgSymbol) RefX 

func (e *TagSvgSymbol) RefX(value interface{}) (ref *TagSvgSymbol)

RefX

English:

The refX attribute defines the x coordinate of an element's reference point. 

Input:
  value: defines the x coordinate of an element's reference point
    float32: 1.0 = "100%"
    const: KPositionHorizontal... (e.g. KPositionHorizontalLeft)
    any other type: interface{}

Português:

O atributo refX define a coordenada x do ponto de referência de um elemento. 

Entrada:
  value: define a coordenada x do ponto de referência de um elemento
    float32: 1.0 = "100%"
    const: KPositionHorizontal... (ex. KPositionHorizontalLeft)
    qualquer outro tipo: interface{}

func (*TagSvgSymbol) RefY 

func (e *TagSvgSymbol) RefY(value interface{}) (ref *TagSvgSymbol)

RefY

English:

The refX attribute defines the y coordinate of an element's reference point. 

Input:
  value: defines the y coordinate of an element's reference point
    float32: 1.0 = "100%"
    const: KPositionVertical... (e.g. KPositionVerticalTop)
    any other type: interface{}

Português:

O atributo refX define a coordenada y do ponto de referência de um elemento. 

Entrada:
  value: define a coordenada y do ponto de referência de um elemento
    float32: 1.0 = "100%"
    const: KPositionVertical... (ex. KPositionVerticalTop)
    qualquer outro tipo: interface{}

func (*TagSvgSymbol) ShapeRendering 

func (e *TagSvgSymbol) ShapeRendering(value interface{}) (ref *TagSvgSymbol)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgSymbol) StopColor 

func (e *TagSvgSymbol) StopColor(value interface{}) (ref *TagSvgSymbol)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgSymbol) StopOpacity 

func (e *TagSvgSymbol) StopOpacity(value interface{}) (ref *TagSvgSymbol)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgSymbol) Stroke 

func (e *TagSvgSymbol) Stroke(value interface{}) (ref *TagSvgSymbol)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgSymbol) StrokeDasharray 

func (e *TagSvgSymbol) StrokeDasharray(value interface{}) (ref *TagSvgSymbol)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgSymbol) StrokeLineCap 

func (e *TagSvgSymbol) StrokeLineCap(value interface{}) (ref *TagSvgSymbol)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgSymbol) StrokeLineJoin 

func (e *TagSvgSymbol) StrokeLineJoin(value interface{}) (ref *TagSvgSymbol)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgSymbol) StrokeMiterLimit 

func (e *TagSvgSymbol) StrokeMiterLimit(value float64) (ref *TagSvgSymbol)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgSymbol) StrokeOpacity 

func (e *TagSvgSymbol) StrokeOpacity(value interface{}) (ref *TagSvgSymbol)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgSymbol) StrokeWidth 

func (e *TagSvgSymbol) StrokeWidth(value interface{}) (ref *TagSvgSymbol)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgSymbol) Style 

func (e *TagSvgSymbol) Style(value string) (ref *TagSvgSymbol)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgSymbol) Tabindex 

func (e *TagSvgSymbol) Tabindex(value int) (ref *TagSvgSymbol)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgSymbol) Text 

func (e *TagSvgSymbol) Text(value string) (ref *TagSvgSymbol)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgSymbol) TextAnchor 

func (e *TagSvgSymbol) TextAnchor(value interface{}) (ref *TagSvgSymbol)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgSymbol) TextDecoration 

func (e *TagSvgSymbol) TextDecoration(value interface{}) (ref *TagSvgSymbol)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgSymbol) TextRendering 

func (e *TagSvgSymbol) TextRendering(value interface{}) (ref *TagSvgSymbol)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgSymbol) Transform 

func (e *TagSvgSymbol) Transform(value interface{}) (ref *TagSvgSymbol)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgSymbol) UnicodeBidi 

func (e *TagSvgSymbol) UnicodeBidi(value interface{}) (ref *TagSvgSymbol)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgSymbol) VectorEffect 

func (e *TagSvgSymbol) VectorEffect(value interface{}) (ref *TagSvgSymbol)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgSymbol) ViewBox 

func (e *TagSvgSymbol) ViewBox(value interface{}) (ref *TagSvgSymbol)

ViewBox

English:

The viewBox attribute defines the position and dimension, in user space, of an SVG viewport. 

Input:
  value: defines the position and dimension, in user space, of an SVG viewport
    []float64: ex. []float64{0.0, 0.0, 10.0, 10.0} = "0 0 10 10"
    any other type: interface{}

The value of the viewBox attribute is a list of four numbers: min-x, min-y, width and height. The numbers, which are separated by whitespace and/or a comma, specify a rectangle in user space which is mapped to the bounds of the viewport established for the associated SVG element (not the browser viewport).

Português:

O atributo viewBox define a posição e a dimensão, no espaço do usuário, de uma viewport SVG. 

Input:
  value: define a posição e dimensão, no espaço do usuário, de uma viewport SVG
    []float64: ex. []float64{0.0, 0.0, 10.0, 10.0} = "0 0 10 10"
    qualquer outro tipo: interface{}

O valor do atributo viewBox é uma lista de quatro números: min-x, min-y, largura e altura. Os números, que são separados por espaço em branco e ou vírgula, especificam um retângulo no espaço do usuário que é mapeado para os limites da janela de visualização estabelecida para o elemento SVG associado (não a janela de visualização do navegador).

func (*TagSvgSymbol) Visibility 

func (e *TagSvgSymbol) Visibility(value interface{}) (ref *TagSvgSymbol)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgSymbol) Width 

func (e *TagSvgSymbol) Width(value interface{}) (ref *TagSvgSymbol)

Width

English:

The width attribute defines the horizontal length of an element in the user coordinate system. 

Input:
  value: the horizontal length of an element
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo largura define o comprimento horizontal de um elemento no sistema de coordenadas do usuário. 

Entrada:
  value: o comprimento horizontal de um elemento
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgSymbol) WordSpacing 

func (e *TagSvgSymbol) WordSpacing(value interface{}) (ref *TagSvgSymbol)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgSymbol) WritingMode 

func (e *TagSvgSymbol) WritingMode(value interface{}) (ref *TagSvgSymbol)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgSymbol) X 

func (e *TagSvgSymbol) X(value interface{}) (ref *TagSvgSymbol)

X

English:

The x attribute defines an x-axis coordinate in the user coordinate system. 

Input:
  value: defines an x-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo x define uma coordenada do eixo x no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo x
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgSymbol) XmlLang 

func (e *TagSvgSymbol) XmlLang(value interface{}) (ref *TagSvgSymbol)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

func (*TagSvgSymbol) Y 

func (e *TagSvgSymbol) Y(value interface{}) (ref *TagSvgSymbol)

Y

English:

The y attribute defines an y-axis coordinate in the user coordinate system. 

Input:
  value: defines an y-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo y define uma coordenada do eixo y no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo y
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

type TagSvgTSpan 

type TagSvgTSpan struct {
	// contains filtered or unexported fields
}

TagSvgTSpan

English:

The SVG <tspan> element defines a subtext within a <text> element or another <tspan> element. It allows for adjustment of the style and/or position of that subtext as needed.

Português:

O elemento SVG <tspan> define um subtexto dentro de um elemento <text> ou outro elemento <tspan>. Permite o ajuste do estilo eou posição desse subtexto conforme necessário.

func (*TagSvgTSpan) Append 

func (e *TagSvgTSpan) Append(elements ...Compatible) (ref *TagSvgTSpan)

func (*TagSvgTSpan) AppendById 

func (e *TagSvgTSpan) AppendById(appendId string) (ref *TagSvgTSpan)

func (*TagSvgTSpan) AppendToElement 

func (e *TagSvgTSpan) AppendToElement(el js.Value) (ref *TagSvgTSpan)

func (*TagSvgTSpan) AppendToStage 

func (e *TagSvgTSpan) AppendToStage() (ref *TagSvgTSpan)

func (*TagSvgTSpan) BaselineShift 

func (e *TagSvgTSpan) BaselineShift(baselineShift interface{}) (ref *TagSvgTSpan)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgTSpan) Class 

func (e *TagSvgTSpan) Class(class string) (ref *TagSvgTSpan)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgTSpan) ClipPath 

func (e *TagSvgTSpan) ClipPath(clipPath string) (ref *TagSvgTSpan)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgTSpan) ClipRule 

func (e *TagSvgTSpan) ClipRule(value interface{}) (ref *TagSvgTSpan)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgTSpan) Color 

func (e *TagSvgTSpan) Color(value interface{}) (ref *TagSvgTSpan)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgTSpan) ColorInterpolation 

func (e *TagSvgTSpan) ColorInterpolation(value interface{}) (ref *TagSvgTSpan)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgTSpan) ColorInterpolationFilters 

func (e *TagSvgTSpan) ColorInterpolationFilters(value interface{}) (ref *TagSvgTSpan)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgTSpan) CreateElement 

func (e *TagSvgTSpan) CreateElement() (ref *TagSvgTSpan)

func (*TagSvgTSpan) Cursor 

func (e *TagSvgTSpan) Cursor(cursor SvgCursor) (ref *TagSvgTSpan)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgTSpan) Direction 

func (e *TagSvgTSpan) Direction(direction SvgDirection) (ref *TagSvgTSpan)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgTSpan) Display 

func (e *TagSvgTSpan) Display(value interface{}) (ref *TagSvgTSpan)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgTSpan) DominantBaseline 

func (e *TagSvgTSpan) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgTSpan)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgTSpan) Dx 

func (e *TagSvgTSpan) Dx(value interface{}) (ref *TagSvgTSpan)

Dx

English: 

The dx attribute indicates a shift along the x-axis on the position of an element or its content.

 Input:
   dx: indicates a shift along the x-axis on the position of an element or its content.
     []float32: []float64{0.0, 0.1} = "0% 10%"
     []float64: []float64{0.0, 10.0} = "0 10"
     float32: 0.1 = "10%"
     float64: 10.0 = "10"
     any other type: interface{}

Portuguese 

O atributo dx indica um deslocamento ao longo do eixo x na posição de um elemento ou seu conteúdo.

 Entrada:
   dx: indica um deslocamento ao longo do eixo x na posição de um elemento ou seu conteúdo.
     []float32: []float64{0.0, 0.1} = "0% 10%"
     []float64: []float64{0.0, 10.0} = "0 10"
     float32: 0.1 = "10%"
     float64: 10.0 = "10"
     qualquer outro tipo: interface{}

func (*TagSvgTSpan) Dy 

func (e *TagSvgTSpan) Dy(value interface{}) (ref *TagSvgTSpan)

Dy

English: 

The dy attribute indicates a shift along the y-axis on the position of an element or its content.

 Input:
   dy: indicates a shift along the y-axis on the position of an element or its content.
     []float32: []float64{0.0, 0.1} = "0% 10%"
     []float64: []float64{0.0, 10.0} = "0 10"
     float32: 0.1 = "10%"
     float64: 10.0 = "10"
     any other type: interface{}

Portuguese 

O atributo dy indica um deslocamento ao longo do eixo y na posição de um elemento ou seu conteúdo.

 Entrada:
   dy: indica um deslocamento ao longo do eixo y na posição de um elemento ou seu conteúdo.
     []float32: []float64{0.0, 0.1} = "0% 10%"
     []float64: []float64{0.0, 10.0} = "0 10"
     float32: 0.1 = "10%"
     float64: 10.0 = "10"
     qualquer outro tipo: interface{}

func (*TagSvgTSpan) Fill 

func (e *TagSvgTSpan) Fill(value interface{}) (ref *TagSvgTSpan)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgTSpan) FillOpacity 

func (e *TagSvgTSpan) FillOpacity(value interface{}) (ref *TagSvgTSpan)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgTSpan) FillRule 

func (e *TagSvgTSpan) FillRule(fillRule SvgFillRule) (ref *TagSvgTSpan)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgTSpan) Filter 

func (e *TagSvgTSpan) Filter(filter string) (ref *TagSvgTSpan)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgTSpan) FloodColor 

func (e *TagSvgTSpan) FloodColor(floodColor interface{}) (ref *TagSvgTSpan)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgTSpan) FloodOpacity 

func (e *TagSvgTSpan) FloodOpacity(floodOpacity float64) (ref *TagSvgTSpan)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgTSpan) FontFamily 

func (e *TagSvgTSpan) FontFamily(fontFamily string) (ref *TagSvgTSpan)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgTSpan) FontSize 

func (e *TagSvgTSpan) FontSize(fontSize interface{}) (ref *TagSvgTSpan)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgTSpan) FontSizeAdjust 

func (e *TagSvgTSpan) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgTSpan)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgTSpan) FontStretch 

func (e *TagSvgTSpan) FontStretch(fontStretch interface{}) (ref *TagSvgTSpan)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgTSpan) FontStyle 

func (e *TagSvgTSpan) FontStyle(fontStyle FontStyleRule) (ref *TagSvgTSpan)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgTSpan) FontVariant 

func (e *TagSvgTSpan) FontVariant(value interface{}) (ref *TagSvgTSpan)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgTSpan) FontWeight 

func (e *TagSvgTSpan) FontWeight(value interface{}) (ref *TagSvgTSpan)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgTSpan) Get 

func (e *TagSvgTSpan) Get() (el js.Value)

func (*TagSvgTSpan) Html 

func (e *TagSvgTSpan) Html(value string) (ref *TagSvgTSpan)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgTSpan) Id 

func (e *TagSvgTSpan) Id(id string) (ref *TagSvgTSpan)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgTSpan) ImageRendering 

func (e *TagSvgTSpan) ImageRendering(imageRendering string) (ref *TagSvgTSpan)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgTSpan) Init 

func (e *TagSvgTSpan) Init() (ref *TagSvgTSpan)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgTSpan) Lang 

func (e *TagSvgTSpan) Lang(value interface{}) (ref *TagSvgTSpan)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgTSpan) LengthAdjust 

func (e *TagSvgTSpan) LengthAdjust(value interface{}) (ref *TagSvgTSpan)

LengthAdjust

English:

The lengthAdjust attribute controls how the text is stretched into the length defined by the textLength attribute. 

Input:
  value: controls how the text is stretched
    KSvgLengthAdjust... (e.g. KSvgLengthAdjustSpacing)

Português:

O atributo lengthAdjust controla como o texto é esticado no comprimento definido pelo atributo textLength. 

Input:
  value: controla como o texto é esticado
    KSvgLengthAdjust... (e.g. KSvgLengthAdjustSpacing)

func (*TagSvgTSpan) LetterSpacing 

func (e *TagSvgTSpan) LetterSpacing(value float64) (ref *TagSvgTSpan)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgTSpan) LightingColor 

func (e *TagSvgTSpan) LightingColor(value interface{}) (ref *TagSvgTSpan)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgTSpan) MarkerEnd 

func (e *TagSvgTSpan) MarkerEnd(value interface{}) (ref *TagSvgTSpan)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgTSpan) MarkerMid 

func (e *TagSvgTSpan) MarkerMid(value interface{}) (ref *TagSvgTSpan)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgTSpan) MarkerStart 

func (e *TagSvgTSpan) MarkerStart(value interface{}) (ref *TagSvgTSpan)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgTSpan) Mask 

func (e *TagSvgTSpan) Mask(value interface{}) (ref *TagSvgTSpan)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgTSpan) Opacity 

func (e *TagSvgTSpan) Opacity(value interface{}) (ref *TagSvgTSpan)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgTSpan) Overflow 

func (e *TagSvgTSpan) Overflow(value interface{}) (ref *TagSvgTSpan)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgTSpan) PaintOrder 

func (e *TagSvgTSpan) PaintOrder(value interface{}) (ref *TagSvgTSpan)

PaintOrder

English:

The paint-order attribute specifies the order that the fill, stroke, and markers of a given shape or text element are painted. 

Input:
  value: specifies the order that the fill, stroke, and markers
    const: SvgPaintOrder... (e.g. KSvgPaintOrderStroke)
    any other type: interface{}

Notes:
  * As a presentation attribute, paint-order can be used as a CSS property.

Português:

O atributo paint-order especifica a ordem em que o preenchimento, o traçado e os marcadores de uma determinada forma ou elemento de texto são pintados. 

Entrada:
  value: especifica a ordem em que o preenchimento, o traçado e os marcadores
    const: SvgPaintOrder... (e.g. KSvgPaintOrderStroke)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, paint-order pode ser usado como uma propriedade CSS.

func (*TagSvgTSpan) PointerEvents 

func (e *TagSvgTSpan) PointerEvents(value interface{}) (ref *TagSvgTSpan)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgTSpan) Rotate 

func (e *TagSvgTSpan) Rotate(value interface{}) (ref *TagSvgTSpan)

Rotate

English:

The rotate attribute specifies how the animated element rotates as it travels along a path specified in an <animateMotion> element. 

Input:
  value: specifies how the animated element rotates
    const: KSvgRotate... (e.g. KSvgRotateAutoReverse)
    any other type: interface{}

Português:

O atributo de rotação especifica como o elemento animado gira enquanto percorre um caminho especificado em um elemento <animateMotion>. 

Entrada:
  value: especifica como o elemento animado gira
    const: KSvgRotate... (e.g. KSvgRotateAutoReverse)
    qualquer outro tipo: interface{}

func (*TagSvgTSpan) ShapeRendering 

func (e *TagSvgTSpan) ShapeRendering(value interface{}) (ref *TagSvgTSpan)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgTSpan) StopColor 

func (e *TagSvgTSpan) StopColor(value interface{}) (ref *TagSvgTSpan)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgTSpan) StopOpacity 

func (e *TagSvgTSpan) StopOpacity(value interface{}) (ref *TagSvgTSpan)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgTSpan) Stroke 

func (e *TagSvgTSpan) Stroke(value interface{}) (ref *TagSvgTSpan)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgTSpan) StrokeDashOffset 

func (e *TagSvgTSpan) StrokeDashOffset(value interface{}) (ref *TagSvgTSpan)

StrokeDashOffset

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    float32: 0.1 = "10%"
    []float32: (e.g. []float32{0.04, 0.01, 0.02}) = "4% 1% 2%"
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    float32: 0.1 = "10%"
    []float32: (e.g. []float32{0.04, 0.01, 0.02}) = "4% 1% 2%"
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgTSpan) StrokeDasharray 

func (e *TagSvgTSpan) StrokeDasharray(value interface{}) (ref *TagSvgTSpan)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgTSpan) StrokeLineCap 

func (e *TagSvgTSpan) StrokeLineCap(value interface{}) (ref *TagSvgTSpan)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgTSpan) StrokeLineJoin 

func (e *TagSvgTSpan) StrokeLineJoin(value interface{}) (ref *TagSvgTSpan)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgTSpan) StrokeMiterLimit 

func (e *TagSvgTSpan) StrokeMiterLimit(value float64) (ref *TagSvgTSpan)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgTSpan) StrokeOpacity 

func (e *TagSvgTSpan) StrokeOpacity(value interface{}) (ref *TagSvgTSpan)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgTSpan) StrokeWidth 

func (e *TagSvgTSpan) StrokeWidth(value interface{}) (ref *TagSvgTSpan)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgTSpan) Style 

func (e *TagSvgTSpan) Style(value string) (ref *TagSvgTSpan)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgTSpan) SystemLanguage 

func (e *TagSvgTSpan) SystemLanguage(value interface{}) (ref *TagSvgTSpan)

SystemLanguage

English:

The systemLanguage attribute represents a list of supported language tags. This list is matched against the language defined in the user preferences.

Português:

O atributo systemLanguage representa uma lista de tags de idioma com suporte. Esta lista é comparada com o idioma definido nas preferências do usuário.

func (*TagSvgTSpan) Tabindex 

func (e *TagSvgTSpan) Tabindex(value int) (ref *TagSvgTSpan)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgTSpan) Text 

func (e *TagSvgTSpan) Text(value string) (ref *TagSvgTSpan)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgTSpan) TextAnchor 

func (e *TagSvgTSpan) TextAnchor(value interface{}) (ref *TagSvgTSpan)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgTSpan) TextDecoration 

func (e *TagSvgTSpan) TextDecoration(value interface{}) (ref *TagSvgTSpan)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgTSpan) TextLength 

func (e *TagSvgTSpan) TextLength(value interface{}) (ref *TagSvgTSpan)

TextLength

English:

The textLength attribute, available on SVG <text> and <tspan> elements, lets you specify the width of the space into which the text will draw. The user agent will ensure that the text does not extend farther than that distance, using the method or methods specified by the lengthAdjust attribute. By default, only the spacing between characters is adjusted, but the glyph size can also be adjusted if you change lengthAdjust. 

Input:
  value: specify the width of the space into which the text will draw
    float32: 1.0 = "100%"
    any other type: interface{}

By using textLength, you can ensure that your SVG text displays at the same width regardless of conditions including web fonts failing to load (or not having loaded yet).

Português:

O atributo textLength, disponível nos elementos SVG <text> e <tspan>, permite especificar a largura do espaço no qual o texto será desenhado. O agente do usuário garantirá que o texto não se estenda além dessa distância, usando o método ou métodos especificados pelo atributo lengthAdjust. Por padrão, apenas o espaçamento entre os caracteres é ajustado, mas o tamanho do glifo também pode ser ajustado se você alterar o lengthAdjust. 

Input:
  value: especifique a largura do espaço no qual o texto será desenhado
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Ao usar textLength, você pode garantir que seu texto SVG seja exibido na mesma largura, independentemente das condições, incluindo fontes da Web que não carregam (ou ainda não foram carregadas).

func (*TagSvgTSpan) TextRendering 

func (e *TagSvgTSpan) TextRendering(value interface{}) (ref *TagSvgTSpan)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgTSpan) Transform 

func (e *TagSvgTSpan) Transform(value interface{}) (ref *TagSvgTSpan)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgTSpan) UnicodeBidi 

func (e *TagSvgTSpan) UnicodeBidi(value interface{}) (ref *TagSvgTSpan)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgTSpan) VectorEffect 

func (e *TagSvgTSpan) VectorEffect(value interface{}) (ref *TagSvgTSpan)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgTSpan) Visibility 

func (e *TagSvgTSpan) Visibility(value interface{}) (ref *TagSvgTSpan)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgTSpan) WordSpacing 

func (e *TagSvgTSpan) WordSpacing(value interface{}) (ref *TagSvgTSpan)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgTSpan) WritingMode 

func (e *TagSvgTSpan) WritingMode(value interface{}) (ref *TagSvgTSpan)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgTSpan) X 

func (e *TagSvgTSpan) X(value interface{}) (ref *TagSvgTSpan)

X

English:

The x attribute defines an x-axis coordinate in the user coordinate system. 

Input:
  value: defines an x-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo x define uma coordenada do eixo x no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo x
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgTSpan) XmlLang 

func (e *TagSvgTSpan) XmlLang(value interface{}) (ref *TagSvgTSpan)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

func (*TagSvgTSpan) Y 

func (e *TagSvgTSpan) Y(value interface{}) (ref *TagSvgTSpan)

Y

English:

The y attribute defines an y-axis coordinate in the user coordinate system. 

Input:
  value: defines an y-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo y define uma coordenada do eixo y no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo y
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

type TagSvgText 

type TagSvgText struct {
	// contains filtered or unexported fields
}

TagSvgText

English:

The SVG <text> element draws a graphics element consisting of text. It's possible to apply a gradient, pattern, clipping path, mask, or filter to <text>, like any other SVG graphics element.

If text is included in SVG not inside of a <text> element, it is not rendered. This is different than being hidden by default, as setting the display property won't show the text.

Português:

O elemento SVG <text> desenha um elemento gráfico que consiste em texto. É possível aplicar um gradiente, padrão, caminho de recorte, máscara ou filtro a <text>, como qualquer outro elemento gráfico SVG.

Se o texto for incluído no SVG fora de um elemento <text>, ele não será renderizado. Isso é diferente de estar oculto por padrão, pois definir a propriedade de exibição não mostrará o texto.

func (*TagSvgText) AlignmentBaseline 

func (e *TagSvgText) AlignmentBaseline(alignmentBaseline interface{}) (ref *TagSvgText)

AlignmentBaseline

English: 

The alignment-baseline attribute specifies how an object is aligned with respect to its parent. This property
specifies which baseline of this element is to be aligned with the corresponding baseline of the parent.
For example, this allows alphabetic baselines in Roman text to stay aligned across font size changes.
It defaults to the baseline with the same name as the computed value of the alignment-baseline property.

 Input:
   alignmentBaseline: specifies how an object is aligned with respect to its parent.
     string: url(#myClip)
     consts KSvgAlignmentBaseline... (e.g. KSvgAlignmentBaselineTextBeforeEdge)
     any other type: interface{}

 Notes:
   * As a presentation attribute alignment-baseline can be used as a CSS property.
   * SVG 2 introduces some changes to the definition of this property. In particular: the values auto, before-edge,
     and after-edge have been removed. For backwards compatibility, text-before-edge may be mapped to text-top and
     text-after-edge to text-bottom. Neither text-before-edge nor text-after-edge should be used with the
     vertical-align property.

Português: 

O atributo alinhamento-base especifica como um objeto é alinhado em relação ao seu pai. Esta propriedade especifica
qual linha de base deste elemento deve ser alinhada com a linha de base correspondente do pai. Por exemplo, isso
permite que as linhas de base alfabéticas em texto romano permaneçam alinhadas nas alterações de tamanho da fonte.
O padrão é a linha de base com o mesmo nome que o valor calculado da propriedade de linha de base de alinhamento.

 Input:
   alignmentBaseline: especifica como um objeto é alinhado em relação ao seu pai.
     string: url(#myClip)
     consts KSvgAlignmentBaseline...  (ex. KSvgAlignmentBaselineTextBeforeEdge)
     qualquer outro tipo: interface{}

 Notas:
   * Como um atributo de apresentação, a linha de base de alinhamento pode ser usada como uma propriedade CSS.
   * O SVG 2 introduz algumas mudanças na definição desta propriedade. Em particular: os valores auto, before-edge e
     after-edge foram removidos. Para compatibilidade com versões anteriores, text-before-edge pode ser mapeado para
     text-top e text-after-edge para text-bottom. Nem text-before-edge nem text-after-edge devem ser usados com a
     propriedade vertical-align.

func (*TagSvgText) Append 

func (e *TagSvgText) Append(elements ...Compatible) (ref *TagSvgText)

func (*TagSvgText) AppendById 

func (e *TagSvgText) AppendById(appendId string) (ref *TagSvgText)

func (*TagSvgText) AppendToElement 

func (e *TagSvgText) AppendToElement(el js.Value) (ref *TagSvgText)

func (*TagSvgText) AppendToStage 

func (e *TagSvgText) AppendToStage() (ref *TagSvgText)

func (*TagSvgText) BaselineShift 

func (e *TagSvgText) BaselineShift(baselineShift interface{}) (ref *TagSvgText)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgText) Class 

func (e *TagSvgText) Class(class string) (ref *TagSvgText)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgText) ClipPath 

func (e *TagSvgText) ClipPath(clipPath string) (ref *TagSvgText)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgText) ClipRule 

func (e *TagSvgText) ClipRule(value interface{}) (ref *TagSvgText)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgText) Color 

func (e *TagSvgText) Color(value interface{}) (ref *TagSvgText)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgText) ColorInterpolation 

func (e *TagSvgText) ColorInterpolation(value interface{}) (ref *TagSvgText)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgText) ColorInterpolationFilters 

func (e *TagSvgText) ColorInterpolationFilters(value interface{}) (ref *TagSvgText)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgText) CreateElement 

func (e *TagSvgText) CreateElement() (ref *TagSvgText)

func (*TagSvgText) Cursor 

func (e *TagSvgText) Cursor(cursor SvgCursor) (ref *TagSvgText)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgText) Direction 

func (e *TagSvgText) Direction(direction SvgDirection) (ref *TagSvgText)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgText) Display 

func (e *TagSvgText) Display(value interface{}) (ref *TagSvgText)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgText) DominantBaseline 

func (e *TagSvgText) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgText)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgText) Dx 

func (e *TagSvgText) Dx(value interface{}) (ref *TagSvgText)

Dx

English: 

The dx attribute indicates a shift along the x-axis on the position of an element or its content.

 Input:
   dx: indicates a shift along the x-axis on the position of an element or its content.
     []float32: []float64{0.0, 0.1} = "0% 10%"
     []float64: []float64{0.0, 10.0} = "0 10"
     float32: 0.1 = "10%"
     float64: 10.0 = "10"
     any other type: interface{}

Portuguese 

O atributo dx indica um deslocamento ao longo do eixo x na posição de um elemento ou seu conteúdo.

 Entrada:
   dx: indica um deslocamento ao longo do eixo x na posição de um elemento ou seu conteúdo.
     []float32: []float64{0.0, 0.1} = "0% 10%"
     []float64: []float64{0.0, 10.0} = "0 10"
     float32: 0.1 = "10%"
     float64: 10.0 = "10"
     qualquer outro tipo: interface{}

func (*TagSvgText) Dy 

func (e *TagSvgText) Dy(value interface{}) (ref *TagSvgText)

Dy

English: 

The dy attribute indicates a shift along the y-axis on the position of an element or its content.

 Input:
   dy: indicates a shift along the y-axis on the position of an element or its content.
     []float32: []float64{0.0, 0.1} = "0% 10%"
     []float64: []float64{0.0, 10.0} = "0 10"
     float32: 0.1 = "10%"
     float64: 10.0 = "10"
     any other type: interface{}

Portuguese 

O atributo dy indica um deslocamento ao longo do eixo y na posição de um elemento ou seu conteúdo.

 Entrada:
   dy: indica um deslocamento ao longo do eixo y na posição de um elemento ou seu conteúdo.
     []float32: []float64{0.0, 0.1} = "0% 10%"
     []float64: []float64{0.0, 10.0} = "0 10"
     float32: 0.1 = "10%"
     float64: 10.0 = "10"
     qualquer outro tipo: interface{}

func (*TagSvgText) Fill 

func (e *TagSvgText) Fill(value interface{}) (ref *TagSvgText)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgText) FillOpacity 

func (e *TagSvgText) FillOpacity(value interface{}) (ref *TagSvgText)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgText) FillRule 

func (e *TagSvgText) FillRule(fillRule SvgFillRule) (ref *TagSvgText)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgText) Filter 

func (e *TagSvgText) Filter(filter string) (ref *TagSvgText)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgText) FloodColor 

func (e *TagSvgText) FloodColor(floodColor interface{}) (ref *TagSvgText)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgText) FloodOpacity 

func (e *TagSvgText) FloodOpacity(floodOpacity float64) (ref *TagSvgText)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgText) FontFamily 

func (e *TagSvgText) FontFamily(fontFamily string) (ref *TagSvgText)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgText) FontSize 

func (e *TagSvgText) FontSize(fontSize interface{}) (ref *TagSvgText)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgText) FontSizeAdjust 

func (e *TagSvgText) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgText)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgText) FontStretch 

func (e *TagSvgText) FontStretch(fontStretch interface{}) (ref *TagSvgText)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgText) FontStyle 

func (e *TagSvgText) FontStyle(fontStyle FontStyleRule) (ref *TagSvgText)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgText) FontVariant 

func (e *TagSvgText) FontVariant(value interface{}) (ref *TagSvgText)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgText) FontWeight 

func (e *TagSvgText) FontWeight(value interface{}) (ref *TagSvgText)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgText) Get 

func (e *TagSvgText) Get() (el js.Value)

func (*TagSvgText) Html 

func (e *TagSvgText) Html(value string) (ref *TagSvgText)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgText) Id 

func (e *TagSvgText) Id(id string) (ref *TagSvgText)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgText) ImageRendering 

func (e *TagSvgText) ImageRendering(imageRendering string) (ref *TagSvgText)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgText) Init 

func (e *TagSvgText) Init() (ref *TagSvgText)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgText) Lang 

func (e *TagSvgText) Lang(value interface{}) (ref *TagSvgText)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgText) LengthAdjust 

func (e *TagSvgText) LengthAdjust(value interface{}) (ref *TagSvgText)

LengthAdjust

English:

The lengthAdjust attribute controls how the text is stretched into the length defined by the textLength attribute. 

Input:
  value: controls how the text is stretched
    KSvgLengthAdjust... (e.g. KSvgLengthAdjustSpacing)

Português:

O atributo lengthAdjust controla como o texto é esticado no comprimento definido pelo atributo textLength. 

Input:
  value: controla como o texto é esticado
    KSvgLengthAdjust... (e.g. KSvgLengthAdjustSpacing)

func (*TagSvgText) LetterSpacing 

func (e *TagSvgText) LetterSpacing(value float64) (ref *TagSvgText)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgText) LightingColor 

func (e *TagSvgText) LightingColor(value interface{}) (ref *TagSvgText)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgText) MarkerEnd 

func (e *TagSvgText) MarkerEnd(value interface{}) (ref *TagSvgText)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgText) MarkerMid 

func (e *TagSvgText) MarkerMid(value interface{}) (ref *TagSvgText)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgText) MarkerStart 

func (e *TagSvgText) MarkerStart(value interface{}) (ref *TagSvgText)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgText) Mask 

func (e *TagSvgText) Mask(value interface{}) (ref *TagSvgText)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgText) Opacity 

func (e *TagSvgText) Opacity(value interface{}) (ref *TagSvgText)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgText) Overflow 

func (e *TagSvgText) Overflow(value interface{}) (ref *TagSvgText)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgText) PaintOrder 

func (e *TagSvgText) PaintOrder(value interface{}) (ref *TagSvgText)

PaintOrder

English:

The paint-order attribute specifies the order that the fill, stroke, and markers of a given shape or text element are painted. 

Input:
  value: specifies the order that the fill, stroke, and markers
    const: SvgPaintOrder... (e.g. KSvgPaintOrderStroke)
    any other type: interface{}

Notes:
  * As a presentation attribute, paint-order can be used as a CSS property.

Português:

O atributo paint-order especifica a ordem em que o preenchimento, o traçado e os marcadores de uma determinada forma ou elemento de texto são pintados. 

Entrada:
  value: especifica a ordem em que o preenchimento, o traçado e os marcadores
    const: SvgPaintOrder... (e.g. KSvgPaintOrderStroke)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, paint-order pode ser usado como uma propriedade CSS.

func (*TagSvgText) PointerEvents 

func (e *TagSvgText) PointerEvents(value interface{}) (ref *TagSvgText)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgText) Rotate 

func (e *TagSvgText) Rotate(value interface{}) (ref *TagSvgText)

Rotate

English:

The rotate attribute specifies how the animated element rotates as it travels along a path specified in an <animateMotion> element. 

Input:
  value: specifies how the animated element rotates
    const: KSvgRotate... (e.g. KSvgRotateAutoReverse)
    any other type: interface{}

Português:

O atributo de rotação especifica como o elemento animado gira enquanto percorre um caminho especificado em um elemento <animateMotion>. 

Entrada:
  value: especifica como o elemento animado gira
    const: KSvgRotate... (e.g. KSvgRotateAutoReverse)
    qualquer outro tipo: interface{}

func (*TagSvgText) ShapeRendering 

func (e *TagSvgText) ShapeRendering(value interface{}) (ref *TagSvgText)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgText) StopColor 

func (e *TagSvgText) StopColor(value interface{}) (ref *TagSvgText)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgText) StopOpacity 

func (e *TagSvgText) StopOpacity(value interface{}) (ref *TagSvgText)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgText) Stroke 

func (e *TagSvgText) Stroke(value interface{}) (ref *TagSvgText)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgText) StrokeDashOffset 

func (e *TagSvgText) StrokeDashOffset(value interface{}) (ref *TagSvgText)

StrokeDashOffset

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    float32: 0.1 = "10%"
    []float32: (e.g. []float32{0.04, 0.01, 0.02}) = "4% 1% 2%"
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    float32: 0.1 = "10%"
    []float32: (e.g. []float32{0.04, 0.01, 0.02}) = "4% 1% 2%"
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgText) StrokeDasharray 

func (e *TagSvgText) StrokeDasharray(value interface{}) (ref *TagSvgText)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgText) StrokeLineCap 

func (e *TagSvgText) StrokeLineCap(value interface{}) (ref *TagSvgText)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgText) StrokeLineJoin 

func (e *TagSvgText) StrokeLineJoin(value interface{}) (ref *TagSvgText)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgText) StrokeMiterLimit 

func (e *TagSvgText) StrokeMiterLimit(value float64) (ref *TagSvgText)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgText) StrokeOpacity 

func (e *TagSvgText) StrokeOpacity(value interface{}) (ref *TagSvgText)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgText) StrokeWidth 

func (e *TagSvgText) StrokeWidth(value interface{}) (ref *TagSvgText)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgText) Style 

func (e *TagSvgText) Style(value string) (ref *TagSvgText)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgText) SystemLanguage 

func (e *TagSvgText) SystemLanguage(value interface{}) (ref *TagSvgText)

SystemLanguage

English:

The systemLanguage attribute represents a list of supported language tags. This list is matched against the language defined in the user preferences.

Português:

O atributo systemLanguage representa uma lista de tags de idioma com suporte. Esta lista é comparada com o idioma definido nas preferências do usuário.

func (*TagSvgText) Tabindex 

func (e *TagSvgText) Tabindex(value int) (ref *TagSvgText)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgText) Text 

func (e *TagSvgText) Text(value string) (ref *TagSvgText)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgText) TextAnchor 

func (e *TagSvgText) TextAnchor(value interface{}) (ref *TagSvgText)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgText) TextDecoration 

func (e *TagSvgText) TextDecoration(value interface{}) (ref *TagSvgText)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgText) TextLength 

func (e *TagSvgText) TextLength(value interface{}) (ref *TagSvgText)

TextLength

English:

The textLength attribute, available on SVG <text> and <tspan> elements, lets you specify the width of the space into which the text will draw. The user agent will ensure that the text does not extend farther than that distance, using the method or methods specified by the lengthAdjust attribute. By default, only the spacing between characters is adjusted, but the glyph size can also be adjusted if you change lengthAdjust. 

Input:
  value: specify the width of the space into which the text will draw
    float32: 1.0 = "100%"
    any other type: interface{}

By using textLength, you can ensure that your SVG text displays at the same width regardless of conditions including web fonts failing to load (or not having loaded yet).

Português:

O atributo textLength, disponível nos elementos SVG <text> e <tspan>, permite especificar a largura do espaço no qual o texto será desenhado. O agente do usuário garantirá que o texto não se estenda além dessa distância, usando o método ou métodos especificados pelo atributo lengthAdjust. Por padrão, apenas o espaçamento entre os caracteres é ajustado, mas o tamanho do glifo também pode ser ajustado se você alterar o lengthAdjust. 

Input:
  value: especifique a largura do espaço no qual o texto será desenhado
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Ao usar textLength, você pode garantir que seu texto SVG seja exibido na mesma largura, independentemente das condições, incluindo fontes da Web que não carregam (ou ainda não foram carregadas).

func (*TagSvgText) TextRendering 

func (e *TagSvgText) TextRendering(value interface{}) (ref *TagSvgText)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgText) Transform 

func (e *TagSvgText) Transform(value interface{}) (ref *TagSvgText)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgText) UnicodeBidi 

func (e *TagSvgText) UnicodeBidi(value interface{}) (ref *TagSvgText)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgText) VectorEffect 

func (e *TagSvgText) VectorEffect(value interface{}) (ref *TagSvgText)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgText) Visibility 

func (e *TagSvgText) Visibility(value interface{}) (ref *TagSvgText)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgText) WordSpacing 

func (e *TagSvgText) WordSpacing(value interface{}) (ref *TagSvgText)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgText) WritingMode 

func (e *TagSvgText) WritingMode(value interface{}) (ref *TagSvgText)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgText) X 

func (e *TagSvgText) X(value interface{}) (ref *TagSvgText)

X

English:

The x attribute defines an x-axis coordinate in the user coordinate system. 

Input:
  value: defines an x-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo x define uma coordenada do eixo x no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo x
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgText) XmlLang 

func (e *TagSvgText) XmlLang(value interface{}) (ref *TagSvgText)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

func (*TagSvgText) Y 

func (e *TagSvgText) Y(value interface{}) (ref *TagSvgText)

Y

English:

The y attribute defines an y-axis coordinate in the user coordinate system. 

Input:
  value: defines an y-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo y define uma coordenada do eixo y no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo y
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

type TagSvgTextPath 

type TagSvgTextPath struct {
	// contains filtered or unexported fields
}

TagSvgTextPath

English:

To render text along the shape of a <path>, enclose the text in a <textPath> element that has an href attribute with a reference to the <path> element.

Português:

Para renderizar o texto ao longo da forma de um <path>, coloque o texto em um elemento <textPath> que tenha um atributo href com uma referência ao elemento <path>.

func (*TagSvgTextPath) Append 

func (e *TagSvgTextPath) Append(elements ...Compatible) (ref *TagSvgTextPath)

func (*TagSvgTextPath) AppendById 

func (e *TagSvgTextPath) AppendById(appendId string) (ref *TagSvgTextPath)

func (*TagSvgTextPath) AppendToElement 

func (e *TagSvgTextPath) AppendToElement(el js.Value) (ref *TagSvgTextPath)

func (*TagSvgTextPath) AppendToStage 

func (e *TagSvgTextPath) AppendToStage() (ref *TagSvgTextPath)

func (*TagSvgTextPath) BaselineShift 

func (e *TagSvgTextPath) BaselineShift(baselineShift interface{}) (ref *TagSvgTextPath)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgTextPath) Class 

func (e *TagSvgTextPath) Class(class string) (ref *TagSvgTextPath)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgTextPath) ClipPath 

func (e *TagSvgTextPath) ClipPath(clipPath string) (ref *TagSvgTextPath)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgTextPath) ClipRule 

func (e *TagSvgTextPath) ClipRule(value interface{}) (ref *TagSvgTextPath)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgTextPath) Color 

func (e *TagSvgTextPath) Color(value interface{}) (ref *TagSvgTextPath)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgTextPath) ColorInterpolation 

func (e *TagSvgTextPath) ColorInterpolation(value interface{}) (ref *TagSvgTextPath)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgTextPath) ColorInterpolationFilters 

func (e *TagSvgTextPath) ColorInterpolationFilters(value interface{}) (ref *TagSvgTextPath)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgTextPath) CreateElement 

func (e *TagSvgTextPath) CreateElement() (ref *TagSvgTextPath)

func (*TagSvgTextPath) Cursor 

func (e *TagSvgTextPath) Cursor(cursor SvgCursor) (ref *TagSvgTextPath)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgTextPath) Direction 

func (e *TagSvgTextPath) Direction(direction SvgDirection) (ref *TagSvgTextPath)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgTextPath) Display 

func (e *TagSvgTextPath) Display(value interface{}) (ref *TagSvgTextPath)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgTextPath) DominantBaseline 

func (e *TagSvgTextPath) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgTextPath)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgTextPath) Fill 

func (e *TagSvgTextPath) Fill(value interface{}) (ref *TagSvgTextPath)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgTextPath) FillOpacity 

func (e *TagSvgTextPath) FillOpacity(value interface{}) (ref *TagSvgTextPath)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgTextPath) FillRule 

func (e *TagSvgTextPath) FillRule(fillRule SvgFillRule) (ref *TagSvgTextPath)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgTextPath) Filter 

func (e *TagSvgTextPath) Filter(filter string) (ref *TagSvgTextPath)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgTextPath) FloodColor 

func (e *TagSvgTextPath) FloodColor(floodColor interface{}) (ref *TagSvgTextPath)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgTextPath) FloodOpacity 

func (e *TagSvgTextPath) FloodOpacity(floodOpacity float64) (ref *TagSvgTextPath)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgTextPath) FontFamily 

func (e *TagSvgTextPath) FontFamily(fontFamily string) (ref *TagSvgTextPath)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgTextPath) FontSize 

func (e *TagSvgTextPath) FontSize(fontSize interface{}) (ref *TagSvgTextPath)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgTextPath) FontSizeAdjust 

func (e *TagSvgTextPath) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgTextPath)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgTextPath) FontStretch 

func (e *TagSvgTextPath) FontStretch(fontStretch interface{}) (ref *TagSvgTextPath)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgTextPath) FontStyle 

func (e *TagSvgTextPath) FontStyle(fontStyle FontStyleRule) (ref *TagSvgTextPath)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgTextPath) FontVariant 

func (e *TagSvgTextPath) FontVariant(value interface{}) (ref *TagSvgTextPath)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgTextPath) FontWeight 

func (e *TagSvgTextPath) FontWeight(value interface{}) (ref *TagSvgTextPath)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgTextPath) Get 

func (e *TagSvgTextPath) Get() (el js.Value)

func (*TagSvgTextPath) HRef 

func (e *TagSvgTextPath) HRef(href string) (ref *TagSvgTextPath)

HRef

English: 

The href attribute defines a link to a resource as a reference URL. The exact meaning of that link depends on the
context of each element using it.

 Notes:
   * Specifications before SVG 2 defined an xlink:href attribute, which is now rendered obsolete by the href
     attribute.
     If you need to support earlier browser versions, the deprecated xlink:href attribute can be used as a fallback
     in addition to the href attribute, e.g. <use href="some-id" xlink:href="some-id x="5" y="5" />.

Português: 

O atributo href define um link para um recurso como um URL de referência. O significado exato desse link depende do
contexto de cada elemento que o utiliza.

 Notas:
   * As especificações anteriores ao SVG 2 definiam um atributo xlink:href, que agora se torna obsoleto pelo
     atributo href.
     Se você precisar oferecer suporte a versões anteriores do navegador, o atributo obsoleto xlink:href pode ser
     usado como um substituto além do atributo href, por exemplo,
     <use href="some-id" xlink:href="some-id x="5" y="5" />.

func (*TagSvgTextPath) Html 

func (e *TagSvgTextPath) Html(value string) (ref *TagSvgTextPath)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgTextPath) Id 

func (e *TagSvgTextPath) Id(id string) (ref *TagSvgTextPath)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgTextPath) ImageRendering 

func (e *TagSvgTextPath) ImageRendering(imageRendering string) (ref *TagSvgTextPath)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgTextPath) Init 

func (e *TagSvgTextPath) Init() (ref *TagSvgTextPath)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgTextPath) Lang 

func (e *TagSvgTextPath) Lang(value interface{}) (ref *TagSvgTextPath)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgTextPath) LengthAdjust 

func (e *TagSvgTextPath) LengthAdjust(value interface{}) (ref *TagSvgTextPath)

LengthAdjust

English:

The lengthAdjust attribute controls how the text is stretched into the length defined by the textLength attribute. 

Input:
  value: controls how the text is stretched
    KSvgLengthAdjust... (e.g. KSvgLengthAdjustSpacing)

Português:

O atributo lengthAdjust controla como o texto é esticado no comprimento definido pelo atributo textLength. 

Input:
  value: controla como o texto é esticado
    KSvgLengthAdjust... (e.g. KSvgLengthAdjustSpacing)

func (*TagSvgTextPath) LetterSpacing 

func (e *TagSvgTextPath) LetterSpacing(value float64) (ref *TagSvgTextPath)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgTextPath) LightingColor 

func (e *TagSvgTextPath) LightingColor(value interface{}) (ref *TagSvgTextPath)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgTextPath) MarkerEnd 

func (e *TagSvgTextPath) MarkerEnd(value interface{}) (ref *TagSvgTextPath)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgTextPath) MarkerMid 

func (e *TagSvgTextPath) MarkerMid(value interface{}) (ref *TagSvgTextPath)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgTextPath) MarkerStart 

func (e *TagSvgTextPath) MarkerStart(value interface{}) (ref *TagSvgTextPath)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgTextPath) Mask 

func (e *TagSvgTextPath) Mask(value interface{}) (ref *TagSvgTextPath)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgTextPath) Opacity 

func (e *TagSvgTextPath) Opacity(value interface{}) (ref *TagSvgTextPath)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgTextPath) Overflow 

func (e *TagSvgTextPath) Overflow(value interface{}) (ref *TagSvgTextPath)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgTextPath) PaintOrder 

func (e *TagSvgTextPath) PaintOrder(value interface{}) (ref *TagSvgTextPath)

PaintOrder

English:

The paint-order attribute specifies the order that the fill, stroke, and markers of a given shape or text element are painted. 

Input:
  value: specifies the order that the fill, stroke, and markers
    const: SvgPaintOrder... (e.g. KSvgPaintOrderStroke)
    any other type: interface{}

Notes:
  * As a presentation attribute, paint-order can be used as a CSS property.

Português:

O atributo paint-order especifica a ordem em que o preenchimento, o traçado e os marcadores de uma determinada forma ou elemento de texto são pintados. 

Entrada:
  value: especifica a ordem em que o preenchimento, o traçado e os marcadores
    const: SvgPaintOrder... (e.g. KSvgPaintOrderStroke)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, paint-order pode ser usado como uma propriedade CSS.

func (*TagSvgTextPath) Path 

func (e *TagSvgTextPath) Path(value *SvgPath) (ref *TagSvgTextPath)

Path

English:

The path attribute has two different meanings, either it defines a text path along which the characters of a text are rendered, or a motion path along which a referenced element is animated.

Português:

O atributo path tem dois significados diferentes: define um caminho de texto ao longo do qual os caracteres de um texto são renderizados ou um caminho de movimento ao longo do qual um elemento referenciado é animado.

func (*TagSvgTextPath) PointerEvents 

func (e *TagSvgTextPath) PointerEvents(value interface{}) (ref *TagSvgTextPath)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgTextPath) ShapeRendering 

func (e *TagSvgTextPath) ShapeRendering(value interface{}) (ref *TagSvgTextPath)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgTextPath) Side 

func (e *TagSvgTextPath) Side(value interface{}) (ref *TagSvgTextPath)

Side

English:

The side attribute determines the side of a path the text is placed on (relative to the path direction). 

Input:
  value: side of a path the text is placed
    const: KSvgSide... (e.g. KSvgSideRight)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo side determina o lado de um caminho em que o texto é colocado (em relação à direção do caminho). 

Entrada:
  value: lado de um caminho em que o texto é colocado
    const: KSvgSide... (e.g. KSvgSideRight)
    qualquer outro tipo: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgTextPath) Spacing 

func (e *TagSvgTextPath) Spacing(value interface{}) (ref *TagSvgTextPath)

Spacing

English:

The spacing attribute indicates how the user agent should determine the spacing between typographic characters that are to be rendered along a path. 

Input:
  value: indicates how the user agent should determine the spacing
    const: KSvgSpacing... (e.g. KSvgSpacingExact)
    any other type: interface{}

Português:

O atributo spacing indica como o agente do usuário deve determinar o espaçamento entre os caracteres tipográficos que devem ser renderizados ao longo de um caminho. 

Entrada:
  value: indica como o agente do usuário deve determinar o espaçamento
    const: KSvgSpacing... (ex. KSvgSpacingExact)
    qualquer outro tipo: interface{}

func (*TagSvgTextPath) StartOffset 

func (e *TagSvgTextPath) StartOffset(value interface{}) (ref *TagSvgTextPath)

StartOffset

English:

The startOffset attribute defines an offset from the start of the path for the initial current text position along the path after converting the path to the <textPath> element's coordinate system. 

Input:
  value: defines an offset from the start
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo startOffset define um deslocamento do início do caminho para a posição inicial do texto atual ao longo do caminho após a conversão do caminho para o sistema de coordenadas do elemento <textPath>. 

Entrada:
  value: define um deslocamento desde o início
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgTextPath) StopColor 

func (e *TagSvgTextPath) StopColor(value interface{}) (ref *TagSvgTextPath)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgTextPath) StopOpacity 

func (e *TagSvgTextPath) StopOpacity(value interface{}) (ref *TagSvgTextPath)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgTextPath) Stroke 

func (e *TagSvgTextPath) Stroke(value interface{}) (ref *TagSvgTextPath)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgTextPath) StrokeDashOffset 

func (e *TagSvgTextPath) StrokeDashOffset(value interface{}) (ref *TagSvgTextPath)

StrokeDashOffset

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    float32: 0.1 = "10%"
    []float32: (e.g. []float32{0.04, 0.01, 0.02}) = "4% 1% 2%"
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    float32: 0.1 = "10%"
    []float32: (e.g. []float32{0.04, 0.01, 0.02}) = "4% 1% 2%"
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgTextPath) StrokeDasharray 

func (e *TagSvgTextPath) StrokeDasharray(value interface{}) (ref *TagSvgTextPath)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgTextPath) StrokeLineCap 

func (e *TagSvgTextPath) StrokeLineCap(value interface{}) (ref *TagSvgTextPath)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgTextPath) StrokeLineJoin 

func (e *TagSvgTextPath) StrokeLineJoin(value interface{}) (ref *TagSvgTextPath)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgTextPath) StrokeMiterLimit 

func (e *TagSvgTextPath) StrokeMiterLimit(value float64) (ref *TagSvgTextPath)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgTextPath) StrokeOpacity 

func (e *TagSvgTextPath) StrokeOpacity(value interface{}) (ref *TagSvgTextPath)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgTextPath) StrokeWidth 

func (e *TagSvgTextPath) StrokeWidth(value interface{}) (ref *TagSvgTextPath)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgTextPath) Style 

func (e *TagSvgTextPath) Style(value string) (ref *TagSvgTextPath)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgTextPath) SystemLanguage 

func (e *TagSvgTextPath) SystemLanguage(value interface{}) (ref *TagSvgTextPath)

SystemLanguage

English:

The systemLanguage attribute represents a list of supported language tags. This list is matched against the language defined in the user preferences.

Português:

O atributo systemLanguage representa uma lista de tags de idioma com suporte. Esta lista é comparada com o idioma definido nas preferências do usuário.

func (*TagSvgTextPath) Tabindex 

func (e *TagSvgTextPath) Tabindex(value int) (ref *TagSvgTextPath)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgTextPath) Text 

func (e *TagSvgTextPath) Text(value string) (ref *TagSvgTextPath)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgTextPath) TextAnchor 

func (e *TagSvgTextPath) TextAnchor(value interface{}) (ref *TagSvgTextPath)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgTextPath) TextDecoration 

func (e *TagSvgTextPath) TextDecoration(value interface{}) (ref *TagSvgTextPath)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgTextPath) TextLength 

func (e *TagSvgTextPath) TextLength(value interface{}) (ref *TagSvgTextPath)

TextLength

English:

The textLength attribute, available on SVG <text> and <tspan> elements, lets you specify the width of the space into which the text will draw. The user agent will ensure that the text does not extend farther than that distance, using the method or methods specified by the lengthAdjust attribute. By default, only the spacing between characters is adjusted, but the glyph size can also be adjusted if you change lengthAdjust. 

Input:
  value: specify the width of the space into which the text will draw
    float32: 1.0 = "100%"
    any other type: interface{}

By using textLength, you can ensure that your SVG text displays at the same width regardless of conditions including web fonts failing to load (or not having loaded yet).

Português:

O atributo textLength, disponível nos elementos SVG <text> e <tspan>, permite especificar a largura do espaço no qual o texto será desenhado. O agente do usuário garantirá que o texto não se estenda além dessa distância, usando o método ou métodos especificados pelo atributo lengthAdjust. Por padrão, apenas o espaçamento entre os caracteres é ajustado, mas o tamanho do glifo também pode ser ajustado se você alterar o lengthAdjust. 

Input:
  value: especifique a largura do espaço no qual o texto será desenhado
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Ao usar textLength, você pode garantir que seu texto SVG seja exibido na mesma largura, independentemente das condições, incluindo fontes da Web que não carregam (ou ainda não foram carregadas).

func (*TagSvgTextPath) TextRendering 

func (e *TagSvgTextPath) TextRendering(value interface{}) (ref *TagSvgTextPath)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgTextPath) Transform 

func (e *TagSvgTextPath) Transform(value interface{}) (ref *TagSvgTextPath)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgTextPath) UnicodeBidi 

func (e *TagSvgTextPath) UnicodeBidi(value interface{}) (ref *TagSvgTextPath)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgTextPath) VectorEffect 

func (e *TagSvgTextPath) VectorEffect(value interface{}) (ref *TagSvgTextPath)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgTextPath) Visibility 

func (e *TagSvgTextPath) Visibility(value interface{}) (ref *TagSvgTextPath)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgTextPath) WordSpacing 

func (e *TagSvgTextPath) WordSpacing(value interface{}) (ref *TagSvgTextPath)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgTextPath) WritingMode 

func (e *TagSvgTextPath) WritingMode(value interface{}) (ref *TagSvgTextPath)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgTextPath) XLinkHRef deprecated 

func (e *TagSvgTextPath) XLinkHRef(value interface{}) (ref *TagSvgTextPath)

XLinkHRef

English:

Deprecated: use HRef() function

The xlink:href attribute defines a reference to a resource as a reference IRI. The exact meaning of that link depends on the context of each element using it. 

Notes:
  * SVG 2 removed the need for the xlink namespace, so instead of xlink:href you should use href. If you need to
    support earlier browser versions, the deprecated xlink:href attribute can be used as a fallback in addition to
    the href attribute, e.g. <use href="some-id" xlink:href="some-id" x="5" y="5" />.

Português:

Obsoleto: use a função HRef()

O atributo xlink:href define uma referência a um recurso como um IRI de referência. O significado exato desse link depende do contexto de cada elemento que o utiliza. 

Notas:
  * O SVG 2 removeu a necessidade do namespace xlink, então ao invés de xlink:href você deve usar href. Se você
    precisar oferecer suporte a versões anteriores do navegador, o atributo obsoleto xlink:href pode ser usado como
    um substituto além do atributo href, por exemplo, <use href="some-id" xlink:href="some-id" x="5" y="5" >.

func (*TagSvgTextPath) XmlLang 

func (e *TagSvgTextPath) XmlLang(value interface{}) (ref *TagSvgTextPath)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

type TagSvgTitle 

type TagSvgTitle struct {
	// contains filtered or unexported fields
}

TagSvgTitle

English:

The <title> element provides an accessible, short-text description of any SVG container element or graphics element.

Text in a <title> element is not rendered as part of the graphic, but browsers usually display it as a tooltip. If an element can be described by visible text, it is recommended to reference that text with an aria-labelledby attribute rather than using the <title> element. 

Notes:
  * For backward compatibility with SVG 1.1, <title> elements should be the first child element of their parent.

Português:

O elemento <title> fornece uma descrição de texto curto acessível de qualquer elemento de contêiner SVG ou elemento gráfico.

O texto em um elemento <title> não é renderizado como parte do gráfico, mas os navegadores geralmente o exibem como uma dica de ferramenta. Se um elemento puder ser descrito por texto visível, é recomendável fazer referência a esse texto com um atributo aria-labelledby em vez de usar o elemento <title>. 

Notas:
  * Para compatibilidade com versões anteriores com SVG 1.1, os elementos <title> devem ser o primeiro elemento
    filho de seu pai.

func (*TagSvgTitle) Append 

func (e *TagSvgTitle) Append(elements ...Compatible) (ref *TagSvgTitle)

func (*TagSvgTitle) AppendById 

func (e *TagSvgTitle) AppendById(appendId string) (ref *TagSvgTitle)

func (*TagSvgTitle) AppendToElement 

func (e *TagSvgTitle) AppendToElement(el js.Value) (ref *TagSvgTitle)

func (*TagSvgTitle) AppendToStage 

func (e *TagSvgTitle) AppendToStage() (ref *TagSvgTitle)

func (*TagSvgTitle) Class 

func (e *TagSvgTitle) Class(class string) (ref *TagSvgTitle)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgTitle) CreateElement 

func (e *TagSvgTitle) CreateElement() (ref *TagSvgTitle)

func (*TagSvgTitle) Get 

func (e *TagSvgTitle) Get() (el js.Value)

func (*TagSvgTitle) Html 

func (e *TagSvgTitle) Html(value string) (ref *TagSvgTitle)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgTitle) Id 

func (e *TagSvgTitle) Id(id string) (ref *TagSvgTitle)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgTitle) Init 

func (e *TagSvgTitle) Init() (ref *TagSvgTitle)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgTitle) Lang 

func (e *TagSvgTitle) Lang(value interface{}) (ref *TagSvgTitle)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgTitle) Style 

func (e *TagSvgTitle) Style(value string) (ref *TagSvgTitle)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgTitle) Tabindex 

func (e *TagSvgTitle) Tabindex(value int) (ref *TagSvgTitle)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgTitle) Text 

func (e *TagSvgTitle) Text(value string) (ref *TagSvgTitle)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgTitle) Title 

func (e *TagSvgTitle) Title(value string) (ref *TagSvgTitle)

Title

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgTitle) XmlLang 

func (e *TagSvgTitle) XmlLang(value interface{}) (ref *TagSvgTitle)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

type TagSvgUse 

type TagSvgUse struct {
	// contains filtered or unexported fields
}

TagSvgUse

English:

The <use> element takes nodes from within the SVG document, and duplicates them somewhere else.

Português:

O elemento <use> pega nós de dentro do documento SVG e os duplica em outro lugar.

func (*TagSvgUse) Append 

func (e *TagSvgUse) Append(elements ...Compatible) (ref *TagSvgUse)

func (*TagSvgUse) AppendById 

func (e *TagSvgUse) AppendById(appendId string) (ref *TagSvgUse)

func (*TagSvgUse) AppendToElement 

func (e *TagSvgUse) AppendToElement(el js.Value) (ref *TagSvgUse)

func (*TagSvgUse) AppendToStage 

func (e *TagSvgUse) AppendToStage() (ref *TagSvgUse)

func (*TagSvgUse) BaselineShift 

func (e *TagSvgUse) BaselineShift(baselineShift interface{}) (ref *TagSvgUse)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgUse) Class 

func (e *TagSvgUse) Class(class string) (ref *TagSvgUse)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgUse) ClipPath 

func (e *TagSvgUse) ClipPath(clipPath string) (ref *TagSvgUse)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgUse) ClipRule 

func (e *TagSvgUse) ClipRule(value interface{}) (ref *TagSvgUse)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgUse) Color 

func (e *TagSvgUse) Color(value interface{}) (ref *TagSvgUse)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgUse) ColorInterpolation 

func (e *TagSvgUse) ColorInterpolation(value interface{}) (ref *TagSvgUse)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgUse) ColorInterpolationFilters 

func (e *TagSvgUse) ColorInterpolationFilters(value interface{}) (ref *TagSvgUse)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgUse) CreateElement 

func (e *TagSvgUse) CreateElement() (ref *TagSvgUse)

func (*TagSvgUse) Cursor 

func (e *TagSvgUse) Cursor(cursor SvgCursor) (ref *TagSvgUse)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgUse) Direction 

func (e *TagSvgUse) Direction(direction SvgDirection) (ref *TagSvgUse)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgUse) Display 

func (e *TagSvgUse) Display(value interface{}) (ref *TagSvgUse)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgUse) DominantBaseline 

func (e *TagSvgUse) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgUse)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgUse) Fill 

func (e *TagSvgUse) Fill(value interface{}) (ref *TagSvgUse)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgUse) FillOpacity 

func (e *TagSvgUse) FillOpacity(value interface{}) (ref *TagSvgUse)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgUse) FillRule 

func (e *TagSvgUse) FillRule(fillRule SvgFillRule) (ref *TagSvgUse)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgUse) Filter 

func (e *TagSvgUse) Filter(filter string) (ref *TagSvgUse)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgUse) FloodColor 

func (e *TagSvgUse) FloodColor(floodColor interface{}) (ref *TagSvgUse)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgUse) FloodOpacity 

func (e *TagSvgUse) FloodOpacity(floodOpacity float64) (ref *TagSvgUse)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgUse) FontFamily 

func (e *TagSvgUse) FontFamily(fontFamily string) (ref *TagSvgUse)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgUse) FontSize 

func (e *TagSvgUse) FontSize(fontSize interface{}) (ref *TagSvgUse)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgUse) FontSizeAdjust 

func (e *TagSvgUse) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgUse)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgUse) FontStretch 

func (e *TagSvgUse) FontStretch(fontStretch interface{}) (ref *TagSvgUse)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgUse) FontStyle 

func (e *TagSvgUse) FontStyle(fontStyle FontStyleRule) (ref *TagSvgUse)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgUse) FontVariant 

func (e *TagSvgUse) FontVariant(value interface{}) (ref *TagSvgUse)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgUse) FontWeight 

func (e *TagSvgUse) FontWeight(value interface{}) (ref *TagSvgUse)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgUse) Get 

func (e *TagSvgUse) Get() (el js.Value)

func (*TagSvgUse) HRef 

func (e *TagSvgUse) HRef(href string) (ref *TagSvgUse)

HRef

English: 

The href attribute defines a link to a resource as a reference URL. The exact meaning of that link depends on the
context of each element using it.

 Notes:
   * Specifications before SVG 2 defined an xlink:href attribute, which is now rendered obsolete by the href
     attribute.
     If you need to support earlier browser versions, the deprecated xlink:href attribute can be used as a fallback
     in addition to the href attribute, e.g. <use href="some-id" xlink:href="some-id x="5" y="5" />.

Português: 

O atributo href define um link para um recurso como um URL de referência. O significado exato desse link depende do
contexto de cada elemento que o utiliza.

 Notas:
   * As especificações anteriores ao SVG 2 definiam um atributo xlink:href, que agora se torna obsoleto pelo
     atributo href.
     Se você precisar oferecer suporte a versões anteriores do navegador, o atributo obsoleto xlink:href pode ser
     usado como um substituto além do atributo href, por exemplo,
     <use href="some-id" xlink:href="some-id x="5" y="5" />.

func (*TagSvgUse) Height 

func (e *TagSvgUse) Height(height interface{}) (ref *TagSvgUse)

Height

English: 

The height attribute defines the vertical length of an element in the user coordinate system.
     float32: 1.0 = "100%"
     any other type: interface{}

Português: 

O atributo height define o comprimento vertical de um elemento no sistema de coordenadas do usuário.
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

func (*TagSvgUse) Html 

func (e *TagSvgUse) Html(value string) (ref *TagSvgUse)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgUse) Id 

func (e *TagSvgUse) Id(id string) (ref *TagSvgUse)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgUse) ImageRendering 

func (e *TagSvgUse) ImageRendering(imageRendering string) (ref *TagSvgUse)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgUse) Init 

func (e *TagSvgUse) Init() (ref *TagSvgUse)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgUse) Lang 

func (e *TagSvgUse) Lang(value interface{}) (ref *TagSvgUse)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgUse) LetterSpacing 

func (e *TagSvgUse) LetterSpacing(value float64) (ref *TagSvgUse)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgUse) LightingColor 

func (e *TagSvgUse) LightingColor(value interface{}) (ref *TagSvgUse)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgUse) MarkerEnd 

func (e *TagSvgUse) MarkerEnd(value interface{}) (ref *TagSvgUse)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgUse) MarkerMid 

func (e *TagSvgUse) MarkerMid(value interface{}) (ref *TagSvgUse)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgUse) MarkerStart 

func (e *TagSvgUse) MarkerStart(value interface{}) (ref *TagSvgUse)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgUse) Mask 

func (e *TagSvgUse) Mask(value interface{}) (ref *TagSvgUse)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgUse) Opacity 

func (e *TagSvgUse) Opacity(value interface{}) (ref *TagSvgUse)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgUse) Overflow 

func (e *TagSvgUse) Overflow(value interface{}) (ref *TagSvgUse)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgUse) PointerEvents 

func (e *TagSvgUse) PointerEvents(value interface{}) (ref *TagSvgUse)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgUse) ShapeRendering 

func (e *TagSvgUse) ShapeRendering(value interface{}) (ref *TagSvgUse)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgUse) StopColor 

func (e *TagSvgUse) StopColor(value interface{}) (ref *TagSvgUse)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgUse) StopOpacity 

func (e *TagSvgUse) StopOpacity(value interface{}) (ref *TagSvgUse)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgUse) Stroke 

func (e *TagSvgUse) Stroke(value interface{}) (ref *TagSvgUse)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgUse) StrokeDasharray 

func (e *TagSvgUse) StrokeDasharray(value interface{}) (ref *TagSvgUse)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgUse) StrokeLineCap 

func (e *TagSvgUse) StrokeLineCap(value interface{}) (ref *TagSvgUse)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgUse) StrokeLineJoin 

func (e *TagSvgUse) StrokeLineJoin(value interface{}) (ref *TagSvgUse)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgUse) StrokeMiterLimit 

func (e *TagSvgUse) StrokeMiterLimit(value float64) (ref *TagSvgUse)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgUse) StrokeOpacity 

func (e *TagSvgUse) StrokeOpacity(value interface{}) (ref *TagSvgUse)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgUse) StrokeWidth 

func (e *TagSvgUse) StrokeWidth(value interface{}) (ref *TagSvgUse)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgUse) Style 

func (e *TagSvgUse) Style(value string) (ref *TagSvgUse)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgUse) Tabindex 

func (e *TagSvgUse) Tabindex(value int) (ref *TagSvgUse)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgUse) Text 

func (e *TagSvgUse) Text(value string) (ref *TagSvgUse)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgUse) TextAnchor 

func (e *TagSvgUse) TextAnchor(value interface{}) (ref *TagSvgUse)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgUse) TextDecoration 

func (e *TagSvgUse) TextDecoration(value interface{}) (ref *TagSvgUse)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgUse) TextRendering 

func (e *TagSvgUse) TextRendering(value interface{}) (ref *TagSvgUse)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgUse) Transform 

func (e *TagSvgUse) Transform(value interface{}) (ref *TagSvgUse)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgUse) TransformOrigin 

func (e *TagSvgUse) TransformOrigin(value interface{}) (ref *TagSvgUse)

TransformOrigin

English:

The transform-origin SVG attribute sets the origin for an item's transformations. 

Input:
  valueA, valueB: the origin for an item's transformations
    const: KSvgTransformOrigin... (e.g.: KSvgTransformOriginLeft)
    const: []SvgTransformOrigin{KSvgTransformOrigin..., KSvgTransformOrigin...} (e.g.: []SvgTransformOrigin{ KSvgTransformOriginLeft, KSvgTransformOriginTop })
    float32: 1.0 = "100%"
    []float32: []float32{1.0, 0.5} = "100% 50%"
    any other type: interface{}

Notes:
  * As a presentation attribute in SVG, transform-origin corresponds in syntax and behavior to the transform-origin
    property in CSS, and can be used as CSS property to style SVG. See the CSS transform-origin property for more
    information.

Português:

O atributo SVG transform-origin define a origem das transformações de um item. 

Entrada:
  value: a origem das transformações de um item
    const: KSvgTransformOrigin... (ex.: KSvgTransformOriginLeft)
    const: []SvgTransformOrigin{KSvgTransformOrigin..., KSvgTransformOrigin...} (ex.: []SvgTransformOrigin{ KSvgTransformOriginLeft, KSvgTransformOriginTop })
    float32: 1.0 = "100%"
    []float32: []float32{1.0, 0.5} = "100% 50%"
    qualquer outro tipo: interface{}

Notas:
  * Como um atributo de apresentação em SVG, transform-origin corresponde em sintaxe e comportamento à propriedade
    transform-origin em CSS e pode ser usado como propriedade CSS para estilizar SVG. Consulte a propriedade
    transform-origin do CSS para obter mais informações.

func (*TagSvgUse) UnicodeBidi 

func (e *TagSvgUse) UnicodeBidi(value interface{}) (ref *TagSvgUse)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgUse) VectorEffect 

func (e *TagSvgUse) VectorEffect(value interface{}) (ref *TagSvgUse)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgUse) Visibility 

func (e *TagSvgUse) Visibility(value interface{}) (ref *TagSvgUse)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgUse) Width 

func (e *TagSvgUse) Width(value interface{}) (ref *TagSvgUse)

Width

English:

The width attribute defines the horizontal length of an element in the user coordinate system. 

Input:
  value: the horizontal length of an element
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo largura define o comprimento horizontal de um elemento no sistema de coordenadas do usuário. 

Entrada:
  value: o comprimento horizontal de um elemento
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgUse) WordSpacing 

func (e *TagSvgUse) WordSpacing(value interface{}) (ref *TagSvgUse)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgUse) WritingMode 

func (e *TagSvgUse) WritingMode(value interface{}) (ref *TagSvgUse)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgUse) X 

func (e *TagSvgUse) X(value interface{}) (ref *TagSvgUse)

X

English:

The x attribute defines an x-axis coordinate in the user coordinate system. 

Input:
  value: defines an x-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo x define uma coordenada do eixo x no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo x
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

func (*TagSvgUse) XLinkHRef deprecated 

func (e *TagSvgUse) XLinkHRef(value interface{}) (ref *TagSvgUse)

XLinkHRef

English:

Deprecated: use HRef() function

The xlink:href attribute defines a reference to a resource as a reference IRI. The exact meaning of that link depends on the context of each element using it. 

Notes:
  * SVG 2 removed the need for the xlink namespace, so instead of xlink:href you should use href. If you need to
    support earlier browser versions, the deprecated xlink:href attribute can be used as a fallback in addition to
    the href attribute, e.g. <use href="some-id" xlink:href="some-id" x="5" y="5" />.

Português:

Obsoleto: use a função HRef()

O atributo xlink:href define uma referência a um recurso como um IRI de referência. O significado exato desse link depende do contexto de cada elemento que o utiliza. 

Notas:
  * O SVG 2 removeu a necessidade do namespace xlink, então ao invés de xlink:href você deve usar href. Se você
    precisar oferecer suporte a versões anteriores do navegador, o atributo obsoleto xlink:href pode ser usado como
    um substituto além do atributo href, por exemplo, <use href="some-id" xlink:href="some-id" x="5" y="5" >.

func (*TagSvgUse) XmlLang 

func (e *TagSvgUse) XmlLang(value interface{}) (ref *TagSvgUse)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

func (*TagSvgUse) Y 

func (e *TagSvgUse) Y(value interface{}) (ref *TagSvgUse)

Y

English:

The y attribute defines an y-axis coordinate in the user coordinate system. 

Input:
  value: defines an y-axis coordinate
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    any other type: interface{}

Português:

O atributo y define uma coordenada do eixo y no sistema de coordenadas do usuário. 

Entrada:
  value: define uma coordenada do eixo y
    []float64: []float64{0.0, 10.0} = "0, 10"
    []float32: []float64{0.0, 10.0} = "0%, 10%"
    float32: 10.0 = "10%"
    qualquer outro tipo: interface{}

type TagSvgView 

type TagSvgView struct {
	// contains filtered or unexported fields
}

TagSvgView

English:

The <defs> element is used to store graphical objects that will be used at a later time.

Objects created inside a <defs> element are not rendered directly. To display them you have to reference them (with a <use> element for example).

Graphical objects can be referenced from anywhere, however, defining these objects inside of a <defs> element promotes understandability of the SVG content and is beneficial to the overall accessibility of the document.

Português:

O elemento <defs> é usado para armazenar objetos gráficos que serão usados posteriormente.

Objetos criados dentro de um elemento <defs> não são renderizados diretamente. Para exibi-los, você deve referenciá-los (com um elemento <use>, por exemplo).

Graphical objects can be referenced from anywhere, however, defining these objects inside of a <defs> element promotes understandability of the SVG content and is beneficial to the overall accessibility of the document.

func (*TagSvgView) Append 

func (e *TagSvgView) Append(elements ...Compatible) (ref *TagSvgView)

func (*TagSvgView) AppendById 

func (e *TagSvgView) AppendById(appendId string) (ref *TagSvgView)

func (*TagSvgView) AppendToElement 

func (e *TagSvgView) AppendToElement(el js.Value) (ref *TagSvgView)

func (*TagSvgView) AppendToStage 

func (e *TagSvgView) AppendToStage() (ref *TagSvgView)

func (*TagSvgView) BaselineShift 

func (e *TagSvgView) BaselineShift(baselineShift interface{}) (ref *TagSvgView)

BaselineShift

English: 

The baseline-shift attribute allows repositioning of the dominant-baseline relative to the dominant-baseline of the
parent text content element. The shifted object might be a sub- or superscript.

 Input:
   baselineShift: allows repositioning of the dominant-baseline relative to the dominant-baseline of the parent text
   content element.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (e.g. KSvgBaselineShiftAuto)

 Notes:
   * As a presentation attribute baseline-shift can be used as a CSS property.
   * This property is going to be deprecated and authors are advised to use vertical-align instead.

Português: 

O atributo baseline-shift permite o reposicionamento da linha de base dominante em relação à linha de base dominante
do elemento de conteúdo de texto pai. O objeto deslocado pode ser um sub ou sobrescrito.

 Input:
   baselineShift: permite o reposicionamento da linha de base dominante em relação à linha de base dominante do
   elemento de conteúdo de texto pai.
     float32: 0.05 = "5%"
     string: "5%"
     consts KSvgBaselineShift... (ex. KSvgBaselineShiftAuto)

 Notas:
   * Como atributo de apresentação, baseline-shift pode ser usado como propriedade CSS.
   * Essa propriedade será preterida e os autores são aconselhados a usar alinhamento vertical.

func (*TagSvgView) Class 

func (e *TagSvgView) Class(class string) (ref *TagSvgView)

Class

English:

Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements, however, multiple class names must be separated by whitespace characters. 

Input:
  class: Assigns a class name or set of class names to an element

An element's class name serves two key roles:

  • As a style sheet selector, for when an author assigns style information to a set of elements.
  • For general use by the browser.

Português:

Atribui um nome de classe ou um conjunto de nomes de classe à um elemento. Você pode atribuir o mesmo nome ou nomes de classe a qualquer número de elementos, no entanto, vários nomes de classe devem ser separados por caracteres de espaço em branco. 

Entrada:
  class: Atribui um nome de classe ou um conjunto de nomes de classe à um elemento.

O nome de classe de um elemento tem duas funções principais:

  • Como um seletor de folha de estilo, para quando um autor atribui informações de estilo a um conjunto de elementos.
  • Para uso geral pelo navegador.

func (*TagSvgView) ClipPath 

func (e *TagSvgView) ClipPath(clipPath string) (ref *TagSvgView)

ClipPath

English: 

It binds the element it is applied to with a given <clipPath> element.

 Input:
   clipPath: the element it is applied
     (e.g. "url(#myClip)", "circle() fill-box", "circle() stroke-box" or "circle() view-box")

Português: 

Ele associa o elemento ao qual é aplicado a um determinado elemento <clipPath>.

 Entrada:
   clipPath: elemento ao qual é aplicado
     (ex. "url(#myClip)", "circle() fill-box", "circle() stroke-box" ou "circle() view-box")

func (*TagSvgView) ClipRule 

func (e *TagSvgView) ClipRule(value interface{}) (ref *TagSvgView)

ClipRule

English: 

It indicates how to determine what side of a path is inside a shape in order to know how a <clipPath> should clip
its target.

 Input:
   value: side of a path
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     any other type: interface{}

Português: 

Ele indica como determinar qual lado de um caminho está dentro de uma forma para saber como um <clipPath> deve
recortar seu destino.

 Input:
   value: lado de um caminho
     const: KSvgClipRule... (e.g. KSvgClipRuleNonzero)
     qualquer outro tipo: interface{}

func (*TagSvgView) Color 

func (e *TagSvgView) Color(value interface{}) (ref *TagSvgView)

Color

English: 

It provides a potential indirect value (currentcolor) for the fill, stroke, stop-color, flood-color and
lighting-color presentation attributes.

 Input:
   value: potential indirect value of color
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     any other type: interface{}

 Notes:
   * As a presentation attribute, color can be used as a CSS property. See CSS color for further information.

Português: 

Ele fornece um valor indireto potencial (currentcolor) para os atributos de apresentação de preenchimento, traçado,
cor de parada, cor de inundação e cor de iluminação.

 Entrada:
   value: valor indireto potencial da cor
     string: ex. "black"
     factory: ex. factoryColor.NewYellow()
     RGBA: ex. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, a cor pode ser usada como propriedade CSS. Veja cor CSS para mais informações.

func (*TagSvgView) ColorInterpolation 

func (e *TagSvgView) ColorInterpolation(value interface{}) (ref *TagSvgView)

ColorInterpolation

English: 

The color-interpolation attribute specifies the color space for gradient interpolations, color animations, and alpha
compositing.

The color-interpolation property chooses between color operations occurring in the sRGB color space or in a (light energy linear) linearized RGB color space. Having chosen the appropriate color space, component-wise linear interpolation is used.

When a child element is blended into a background, the value of the color-interpolation property on the child determines the type of blending, not the value of the color-interpolation on the parent. For gradients which make use of the href or the deprecated xlink:href attribute to reference another gradient, the gradient uses the property's value from the gradient element which is directly referenced by the fill or stroke property. When animating colors, color interpolation is performed according to the value of the color-interpolation property on the element being animated. 

Notes:
  * For filter effects, the color-interpolation-filters property controls which color space is used.
  * As a presentation attribute, color-interpolation can be used as a CSS property.

Português: 

O atributo color-interpolation especifica o espaço de cores para interpolações de gradiente, animações de cores e
composição alfa.

A propriedade de interpolação de cores escolhe entre operações de cores que ocorrem no espaço de cores sRGB ou em um espaço de cores RGB linearizado (energia de luz linear). Tendo escolhido o espaço de cor apropriado, a interpolação linear de componentes é usada.

Quando um elemento filho é mesclado em um plano de fundo, o valor da propriedade color-interpolation no filho determina o tipo de mesclagem, não o valor da interpolação de cores no pai. Para gradientes que usam o href ou o atributo obsoleto xlink:href para referenciar outro gradiente, o gradiente usa o valor da propriedade do elemento gradiente que é diretamente referenciado pela propriedade fill ou stroke. Ao animar cores, à interpolação de cores é executada de acordo com o valor da propriedade color-interpolation no elemento que está sendo animado. 

Notas:
  * Para efeitos de filtro, a propriedade color-interpolation-filters controla qual espaço de cor é usado.
  * Como atributo de apresentação, a interpolação de cores pode ser usada como uma propriedade CSS.

func (*TagSvgView) ColorInterpolationFilters 

func (e *TagSvgView) ColorInterpolationFilters(value interface{}) (ref *TagSvgView)

ColorInterpolationFilters

English: 

The color-interpolation-filters attribute specifies the color space for imaging operations performed via filter
effects.

 Notes:
   * This property just has an affect on filter operations. Therefore, it has no effect on filter primitives like
     <feOffset>, <feImage>, <feTile> or <feFlood>;
   * color-interpolation-filters has a different initial value than color-interpolation. color-interpolation-filters
     has an initial value of linearRGB, whereas color-interpolation has an initial value of sRGB. Thus, in the
     default case, filter effects operations occur in the linearRGB color space, whereas all other color
     interpolations occur by default in the sRGB color space;
   * It has no affect on filter functions, which operate in the sRGB color space;
   * As a presentation attribute, color-interpolation-filters can be used as a CSS property.

Português: 

O atributo color-interpolation-filters especifica o espaço de cores para operações de imagem realizadas por meio de
efeitos de filtro.

 Notas:
   * Esta propriedade afeta apenas as operações de filtro. Portanto, não tem efeito em primitivos de filtro como
     <feOffset>, <feImage>, <feTile> ou <feFlood>.
   * color-interpolation-filters tem um valor inicial diferente de color-interpolation. color-interpolation-filters
     tem um valor inicial de linearRGB, enquanto color-interpolation tem um valor inicial de sRGB. Assim, no caso
     padrão, as operações de efeitos de filtro ocorrem no espaço de cores linearRGB, enquanto todas as outras
     interpolações de cores ocorrem por padrão no espaço de cores sRGB.
   * Não afeta as funções de filtro, que operam no espaço de cores sRGB.
   * Como atributo de apresentação, os filtros de interpolação de cores podem ser usados como uma propriedade CSS.

func (*TagSvgView) CreateElement 

func (e *TagSvgView) CreateElement() (ref *TagSvgView)

func (*TagSvgView) Cursor 

func (e *TagSvgView) Cursor(cursor SvgCursor) (ref *TagSvgView)

Cursor

English: 

The cursor attribute specifies the mouse cursor displayed when the mouse pointer is over an element.

This attribute behaves exactly like the css cursor property except that if the browser supports the <cursor> element, you should be able to use it with the <funciri> notation.

As a presentation attribute, it also can be used as a property directly inside a CSS stylesheet, see css cursor for further information.

Português: 

O atributo cursor especifica o cursor do mouse exibido quando o ponteiro do mouse está sobre um elemento.

Este atributo se comporta exatamente como a propriedade cursor css, exceto que, se o navegador suportar o elemento <cursor>, você poderá usá-lo com a notação <funciri>.

Como atributo de apresentação, também pode ser usado como propriedade diretamente dentro de uma folha de estilo CSS, veja cursor css para mais informações.

func (*TagSvgView) Direction 

func (e *TagSvgView) Direction(direction SvgDirection) (ref *TagSvgView)

Direction

English: 

The direction attribute specifies the inline-base direction of a <text> or <tspan> element. It defines the start
and end points of a line of text as used by the text-anchor and inline-size properties. It also may affect the
direction in which characters are positioned if the unicode-bidi property's value is either embed or bidi-override.

It applies only to glyphs oriented perpendicular to the inline-base direction, which includes the usual case of horizontally-oriented Latin or Arabic text and the case of narrow-cell Latin or Arabic characters rotated 90 degrees clockwise relative to a top-to-bottom inline-base direction.

In many cases, the bidirectional Unicode algorithm produces the desired result automatically, so this attribute doesn't need to be specified in those cases. For other cases, such as when using right-to-left languages, it may be sufficient to add the direction attribute to the outermost <svg> element, and allow that direction to inherit to all text elements: 

Notes:
  * As a presentation attribute, direction can be used as a CSS property. See css direction for further
    information.

Português: 

O atributo direction especifica a direção da base embutida de um elemento <text> ou <tspan>. Ele define os pontos
inicial e final de uma linha de texto conforme usado pelas propriedades text-anchor e inline-size.
Também pode afetar a direção na qual os caracteres são posicionados se o valor da propriedade unicode-bidi for
incorporado ou substituído por bidi.

Aplica-se apenas a glifos orientados perpendicularmente à direção da base em linha, que inclui o caso usual de texto latino ou árabe orientado horizontalmente e o caso de caracteres latinos ou árabes de célula estreita girados 90 graus no sentido horário em relação a um texto de cima para baixo direção de base em linha.

Em muitos casos, o algoritmo Unicode bidirecional produz o resultado desejado automaticamente, portanto, esse atributo não precisa ser especificado nesses casos. Para outros casos, como ao usar idiomas da direita para a esquerda, pode ser suficiente adicionar o atributo direction ao elemento <svg> mais externo e permitir que essa direção herde todos os elementos de texto: 

Notas:
  * Como atributo de apresentação, a direção pode ser usada como uma propriedade CSS. Veja a direção do CSS para
    mais informações.

func (*TagSvgView) Display 

func (e *TagSvgView) Display(value interface{}) (ref *TagSvgView)

Display

English: 

The display attribute lets you control the rendering of graphical or container elements.

 Input:
   value: control the rendering of graphical or container elements
     nil: display="none"
     const: KSvgDisplay... (e.g. KSvgDisplayBlock)
     any other type: interface{}

A value of display="none" indicates that the given element and its children will not be rendered. Any value other than none or inherit indicates that the given element will be rendered by the browser.

When applied to a container element, setting display to none causes the container and all of its children to be invisible; thus, it acts on groups of elements as a group. This means that any child of an element with display="none" will never be rendered even if the child has a value for display other than none.

When the display attribute is set to none, then the given element does not become part of the rendering tree. It has implications for the <tspan>, <tref>, and <altGlyph> elements, event processing, for bounding box calculations and for calculation of clipping paths:

  • If display is set to none on a <tspan>, <tref>, or <altGlyph> element, then the text string is ignored for the purposes of text layout.
  • Regarding events, if display is set to none, the element receives no events.
  • The geometry of a graphics element with display set to none is not included in bounding box and clipping paths calculations.

The display attribute only affects the direct rendering of a given element, whereas it does not prevent elements from being referenced by other elements. For example, setting it to none on a <path> element will prevent that element from getting rendered directly onto the canvas, but the <path> element can still be referenced by a <textPath> element; furthermore, its geometry will be used in text-on-a-path processing even if the <path> has a display value of none.

This attribute also affects direct rendering into offscreen canvases, such as occurs with masks or clip paths. Thus, setting display="none" on a child of a <mask> will prevent the given child element from being rendered as part of the mask. Similarly, setting display="none" on a child of a <clipPath> element will prevent the given child element from contributing to the clipping path. 

Notes:
  * As a presentation attribute, display can be used as a CSS property. See css display for further information.

Português: 

O atributo display permite controlar a renderização de elementos gráficos ou de contêiner.

 Entrada:
   value: controlar a renderização de elementos gráficos ou de contêiner
     nil: display="none"
     const: KSvgDisplay... (ex. KSvgDisplayBlock)
     qualquer outro tipo: interface{}

Um valor de display="none" indica que o elemento fornecido e seus filhos não serão renderizados. Qualquer valor diferente de none ou herdar indica que o elemento fornecido será renderizado pelo navegador.

Quando aplicado a um elemento de contêiner, definir display como none faz com que o contêiner e todos os seus filhos fiquem invisíveis; assim, atua em grupos de elementos como um grupo. Isso significa que qualquer filho de um elemento com display="none" nunca será renderizado, mesmo que o filho tenha um valor para exibição diferente de none.

Quando o atributo display é definido como none, o elemento fornecido não se torna parte da árvore de renderização. Tem implicações para os elementos <tspan>, <tref> e <altGlyph>, processamento de eventos, para cálculos de caixa delimitadora e para cálculo de caminhos de recorte:

  • Se display for definido como none em um elemento <tspan>, <tref> ou <altGlyph>, a string de texto será ignorada para fins de layout de texto.
  • Com relação aos eventos, se display estiver definido como none, o elemento não recebe eventos.
  • A geometria de um elemento gráfico com exibição definida como nenhum não é incluída nos cálculos da caixa delimitadora e dos caminhos de recorte.

O atributo display afeta apenas a renderização direta de um determinado elemento, mas não impede que os elementos sejam referenciados por outros elementos. Por exemplo, defini-lo como none em um elemento <path> impedirá que esse elemento seja renderizado diretamente na tela, mas o elemento <path> ainda pode ser referenciado por um elemento <textPath>; além disso, sua geometria será usada no processamento de texto em um caminho, mesmo que o <caminho> tenha um valor de exibição de nenhum.

Esse atributo também afeta a renderização direta em telas fora da tela, como ocorre com máscaras ou caminhos de clipe. Assim, definir display="none" em um filho de uma <mask> impedirá que o elemento filho fornecido seja renderizado como parte da máscara. Da mesma forma, definir display="none" em um filho de um elemento <clipPath> impedirá que o elemento filho fornecido contribua para o caminho de recorte. 

Notas:
  * Como atributo de apresentação, display pode ser usado como propriedade CSS. Consulte a exibição css para obter
    mais informações.

func (*TagSvgView) DominantBaseline 

func (e *TagSvgView) DominantBaseline(dominantBaseline SvgDominantBaseline) (ref *TagSvgView)

DominantBaseline

English:

The dominant-baseline attribute specifies the dominant baseline, which is the baseline used to align the box's text and inline-level contents. It also indicates the default alignment baseline of any boxes participating in baseline alignment in the box's alignment context.

It is used to determine or re-determine a scaled-baseline-table. A scaled-baseline-table is a compound value with three components:

  1. a baseline-identifier for the dominant-baseline,
  2. a baseline-table, and
  3. a baseline-table font-size.

Some values of the property re-determine all three values. Others only re-establish the baseline-table font-size. When the initial value, auto, would give an undesired result, this property can be used to explicitly set the desired scaled-baseline-table.

If there is no baseline table in the nominal font, or if the baseline table lacks an entry for the desired baseline, then the browser may use heuristics to determine the position of the desired baseline. 

Notes:
  * As a presentation attribute, dominant-baseline can be used as a CSS property.

Português:

O atributo linha de base dominante especifica a linha de base dominante, que é a linha de base usada para alinhar o texto da caixa e o conteúdo do nível embutido. Também indica a linha de base de alinhamento padrão de todas as caixas que participam do alinhamento da linha de base no contexto de alinhamento da caixa.

Ele é usado para determinar ou re-determinar uma tabela de linha de base dimensionada. Uma tabela de linha de base dimensionada é um valor composto com três componentes:

  1. um identificador de linha de base para a linha de base dominante,
  2. uma tabela de linha de base, e
  3. um tamanho de fonte da tabela de linha de base.

Alguns valores da propriedade redeterminam todos os três valores. Outros apenas restabelecem o tamanho da fonte da tabela de linha de base. Quando o valor inicial, auto, daria um resultado indesejado, essa propriedade pode ser usada para definir explicitamente a tabela de linha de base dimensionada desejada.

Se não houver nenhuma tabela de linha de base na fonte nominal, ou se a tabela de linha de base não tiver uma entrada para a linha de base desejada, o navegador poderá usar heurística para determinar a posição da linha de base desejada. 

Notas:
  * Como atributo de apresentação, a linha de base dominante pode ser usada como uma propriedade CSS.

func (*TagSvgView) Fill 

func (e *TagSvgView) Fill(value interface{}) (ref *TagSvgView)

Fill

English:

The fill attribute has two different meanings. For shapes and text it's a presentation attribute that defines the color (or any SVG paint servers like gradients or patterns) used to paint the element;

for animation it defines the final state of the animation. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Português:

O atributo fill tem dois significados diferentes. Para formas e texto, é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o elemento;

para animação, define o estado final da animação. 

Input:
  value: the fill value
    nil: fill="none"
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

func (*TagSvgView) FillOpacity 

func (e *TagSvgView) FillOpacity(value interface{}) (ref *TagSvgView)

FillOpacity

English: 

The fill-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient,
pattern, etc) applied to a shape.

 Input:
   value: defining the opacity of the paint
     float32: 1.0 = "100%"
     any other type: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

Portuguese 

O atributo fill-opacity é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente,
padrão etc.) aplicado a uma forma.

 Entrada:
   value: definindo a opacidade da tinta
     float32: 1.0 = "100%"
     qualquer outro tipo: interface{}

 Notes:
   *As a presentation attribute fill-opacity can be used as a CSS property.

func (*TagSvgView) FillRule 

func (e *TagSvgView) FillRule(fillRule SvgFillRule) (ref *TagSvgView)

FillRule

English: 

The fill-rule attribute is a presentation attribute defining the algorithm to use to determine the inside part of
a shape.

 Notes:
   * As a presentation attribute, fill-rule can be used as a CSS property.

Portuguese 

O atributo fill-rule é um atributo de apresentação que define o algoritmo a ser usado para determinar a parte
interna de uma forma.

 Notas:
   * Como atributo de apresentação, fill-rule pode ser usado como uma propriedade CSS.

func (*TagSvgView) Filter 

func (e *TagSvgView) Filter(filter string) (ref *TagSvgView)

Filter

English: 

The filter attribute specifies the filter effects defined by the <filter> element that shall be applied to its
element.

 Notes:
   * As a presentation attribute, filter can be used as a CSS property. See css filter for further information.

Portuguese 

O atributo filter especifica os efeitos de filtro definidos pelo elemento <filter> que devem ser aplicados ao seu
elemento.

 Notas:
   * Como atributo de apresentação, o filtro pode ser usado como propriedade CSS. Veja filtro css para mais
     informações.

func (*TagSvgView) FloodColor 

func (e *TagSvgView) FloodColor(floodColor interface{}) (ref *TagSvgView)

FloodColor

English: 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

Portuguese 

The flood-color attribute indicates what color to use to flood the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-color can be used as a CSS property.

func (*TagSvgView) FloodOpacity 

func (e *TagSvgView) FloodOpacity(floodOpacity float64) (ref *TagSvgView)

FloodOpacity

English: 

The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion.

 Notes:
   * As a presentation attribute, flood-opacity can be used as a CSS property.

Portuguese 

O atributo flood-opacity indica o valor de opacidade a ser usado na sub-região primitiva de filtro atual.

 Notas:
   * Como atributo de apresentação, a opacidade de inundação pode ser usada como uma propriedade CSS.

func (*TagSvgView) FontFamily 

func (e *TagSvgView) FontFamily(fontFamily string) (ref *TagSvgView)

FontFamily

English: 

The font-family attribute indicates which font family will be used to render the text, specified as a prioritized
list of font family names and/or generic family names.

 Notes:
   * As a presentation attribute, font-family can be used as a CSS property. See the css font-family property for
     more information.

Portuguese 

O atributo font-family indica qual família de fontes será usada para renderizar o texto, especificada como uma lista
priorizada de nomes de famílias de fontes e ou nomes de famílias genéricos.

 Notas:
   * Como atributo de apresentação, font-family pode ser usada como propriedade CSS. Consulte a propriedade CSS
     font-family para obter mais informações.

func (*TagSvgView) FontSize 

func (e *TagSvgView) FontSize(fontSize interface{}) (ref *TagSvgView)

FontSize

English: 

The font-size attribute refers to the size of the font from baseline to baseline when multiple lines of text are set
solid in a multiline layout environment.

 Notes:
   * As a presentation attribute, font-size can be used as a CSS property. See the css font-size property for more
     information.

Portuguese 

O atributo font-size refere-se ao tamanho da fonte da linha de base a linha de base quando várias linhas de texto
são definidas como sólidas em um ambiente de layout de várias linhas.

 Notas:
   * Como atributo de apresentação, font-size pode ser usado como uma propriedade CSS. Consulte a propriedade CSS
     font-size para obter mais informações.

func (*TagSvgView) FontSizeAdjust 

func (e *TagSvgView) FontSizeAdjust(fontSizeAdjust float64) (ref *TagSvgView)

FontSizeAdjust

English: 

The font-size-adjust attribute allows authors to specify an aspect value for an element that will preserve the
x-height of the first choice font in a substitute font.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

Portuguese 

O atributo font-size-adjust permite que os autores especifiquem um valor de aspecto para um elemento que preservará
a altura x da fonte de primeira escolha em uma fonte substituta.

 Notes:
   * As a presentation attribute, font-size-adjust can be used as a CSS property. See the css font-size-adjust
     property for more information.

func (*TagSvgView) FontStretch 

func (e *TagSvgView) FontStretch(fontStretch interface{}) (ref *TagSvgView)

FontStretch

English: 

The font-stretch attribute indicates the desired amount of condensing or expansion in the glyphs used to render
the text.

 Input:
   fontStretch: indicates the desired amount of condensing or expansion
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notes:
   * As a presentation attribute, font-stretch can be used as a CSS property. See the css font-stretch property for
     more information.

Portuguese 

O atributo font-stretch indica a quantidade desejada de condensação ou expansão nos glifos usados para renderizar
o texto.

 Entrada:
   fontStretch: indica a quantidade desejada de condensação ou expansão
     KSvgFontStretch... (e.g. KSvgFontStretchUltraCondensed)
     percentage (e.g. "50%")

 Notas:
   * Como atributo de apresentação, font-stretch pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-stretch para obter mais informações.

func (*TagSvgView) FontStyle 

func (e *TagSvgView) FontStyle(fontStyle FontStyleRule) (ref *TagSvgView)

FontStyle

English: 

The font-style attribute specifies whether the text is to be rendered using a normal, italic, or oblique face.

 Notes:
   * As a presentation attribute, font-style can be used as a CSS property. See the css font-style property for
     more information.

Portuguese 

O atributo font-style especifica se o texto deve ser renderizado usando uma face normal, itálica ou oblíqua.

 Notas:
   * Como atributo de apresentação, font-style pode ser usado como propriedade CSS. Consulte a propriedade CSS
     font-style para obter mais informações.

func (*TagSvgView) FontVariant 

func (e *TagSvgView) FontVariant(value interface{}) (ref *TagSvgView)

FontVariant

English: 

The font-variant attribute indicates whether the text is to be rendered using variations of the font's glyphs.

 Input:
   value: indicates whether the text is to be rendered
     const: KFontVariantRule... (e.g. KFontVariantRuleSmallCaps)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-variant can be used as a CSS property. See the css font-variant property
     for more information.

Portuguese 

O atributo font-variant indica se o texto deve ser renderizado usando variações dos glifos da fonte.

 Entrada:
   value: indica onde o texto vai ser renderizado.
     const: KFontVariantRule... (ex. KFontVariantRuleSmallCaps)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, font-variant pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-variant para obter mais informações.

func (*TagSvgView) FontWeight 

func (e *TagSvgView) FontWeight(value interface{}) (ref *TagSvgView)

FontWeight

English: 

The font-weight attribute refers to the boldness or lightness of the glyphs used to render the text, relative to
other fonts in the same font family.

 Input:
   value: refers to the boldness or lightness of the glyphs used to render the text
     const: KFontWeightRule... (e.g. KFontWeightRuleBold)
     any other type: interface{}

 Notes:
   * As a presentation attribute, font-weight can be used as a CSS property. See the css font-weight property for
     more information.

Portuguese 

O atributo font-weight refere-se ao negrito ou leveza dos glifos usados para renderizar o texto, em relação a
outras fontes na mesma família de fontes.

 Entrada:
   value: refere-se ao negrito ou leveza dos glifos usados para renderizar o texto
     const: KFontWeightRule... (ex. KFontWeightRuleBold)
     qualquer outro tipo: interface{}

 Notas:
   * Como atributo de apresentação, o peso da fonte pode ser usado como uma propriedade CSS. Consulte a propriedade
     CSS font-weight para obter mais informações.

func (*TagSvgView) Get 

func (e *TagSvgView) Get() (el js.Value)

func (*TagSvgView) Html 

func (e *TagSvgView) Html(value string) (ref *TagSvgView)

Html

English:

Adds HTML to the tag's content.

Text:

Adiciona HTML ao conteúdo da tag.

func (*TagSvgView) Id 

func (e *TagSvgView) Id(id string) (ref *TagSvgView)

Id

English: 

The id attribute assigns a unique name to an element.

Portuguese 

O atributo id atribui um nome exclusivo a um elemento.

func (*TagSvgView) ImageRendering 

func (e *TagSvgView) ImageRendering(imageRendering string) (ref *TagSvgView)

ImageRendering

English: 

The image-rendering attribute provides a hint to the browser about how to make speed vs. quality tradeoffs as it
performs image processing.

The resampling is always done in a truecolor (e.g., 24-bit) color space even if the original data and/or the target device is indexed color. 

Notes:
  * As a presentation attribute, image-rendering can be used as a CSS property. See the css image-rendering
    property for more information.

Portuguese 

O atributo de renderização de imagem fornece uma dica ao navegador sobre como fazer compensações de velocidade
versus qualidade enquanto executa o processamento de imagem.

A reamostragem é sempre feita em um espaço de cores truecolor (por exemplo, 24 bits), mesmo que os dados originais e ou o dispositivo de destino sejam cores indexadas. 

Notas:
  * Como um atributo de apresentação, a renderização de imagem pode ser usada como uma propriedade CSS. Consulte
    a propriedade de renderização de imagem css para obter mais informações.

func (*TagSvgView) Init 

func (e *TagSvgView) Init() (ref *TagSvgView)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagSvgView) Lang 

func (e *TagSvgView) Lang(value interface{}) (ref *TagSvgView)

Lang

English:

The lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language used in contents
    const KLanguage... (e.g. KLanguageEnglish)

There is also an xml:lang attribute (with namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

In SVG 1.1 there was a lang attribute defined with a different meaning and only applying to <glyph> elements. That attribute specified a list of languages according to RFC 5646: Tags for Identifying Languages (also known as BCP 47). The glyph was meant to be used if the xml:lang attribute exactly matched one of the languages given in the value of this parameter, or if the xml:lang attribute exactly equaled a prefix of one of the languages given in the value of this parameter such that the first tag character following the prefix was "-".

Português:

O atributo lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal usado no conteúdo
    const KLanguage... (ex. KLanguagePortuguese)

Há também um atributo xml:lang (com namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

No SVG 1.1 havia um atributo lang definido com um significado diferente e aplicando-se apenas aos elementos <glyph>. Esse atributo especificou uma lista de idiomas de acordo com a RFC 5646: Tags for Identification Languages (também conhecido como BCP 47). O glifo deveria ser usado se o atributo xml:lang correspondesse exatamente a um dos idiomas fornecidos no valor desse parâmetro, ou se o atributo xml:lang fosse exatamente igual a um prefixo de um dos idiomas fornecidos no valor desse parâmetro de modo que o primeiro caractere de tag após o prefixo fosse "-".

func (*TagSvgView) LetterSpacing 

func (e *TagSvgView) LetterSpacing(value float64) (ref *TagSvgView)

LetterSpacing

English:

The letter-spacing attribute controls spacing between text characters, in addition to any spacing from the kerning attribute. 

Input:
  value: controls spacing between text characters

If the attribute value is a unitless number (like 128), the browser processes it as a <length> in the current user coordinate system.

If the attribute value has a unit identifier, such as .25em or 1%, then the browser converts the <length> into its corresponding value in the current user coordinate system.

Notes:

  • As a presentation attribute, letter-spacing can be used as a CSS property. See the css letter-spacing property for more information.

Português:

O atributo letter-spacing controla o espaçamento entre caracteres de texto, além de qualquer espaçamento do atributo kerning. 

Input:
  value: controla o espaçamento entre caracteres de texto

Se o valor do atributo for um número sem unidade (como 128), o navegador o processará como um <comprimento> no sistema de coordenadas do usuário atual.

Se o valor do atributo tiver um identificador de unidade, como .25em ou 1%, o navegador converterá o <comprimento> em seu valor correspondente no sistema de coordenadas do usuário atual.

Notas:

  • Como atributo de apresentação, o espaçamento entre letras pode ser usado como uma propriedade CSS. Consulte a propriedade de espaçamento entre letras do CSS para obter mais informações.

func (*TagSvgView) LightingColor 

func (e *TagSvgView) LightingColor(value interface{}) (ref *TagSvgView)

LightingColor

English:

The lighting-color attribute defines the color of the light source for lighting filter primitives.

Português:

O atributo lighting-color define a cor da fonte de luz para as primitivas do filtro de iluminação.

func (*TagSvgView) MarkerEnd 

func (e *TagSvgView) MarkerEnd(value interface{}) (ref *TagSvgView)

MarkerEnd

English:

The marker-end attribute defines the arrowhead or polymarker that will be drawn at the final vertex of the given shape. 

Input:
  value: the arrowhead or polymarker that will be drawn
    string: (e.g. "url(#triangle)")

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-end is only rendered on the final vertex of the path data.

Notes:

  • As a presentation attribute, marker-end can be used as a CSS property.

Português:

O atributo marker-end define a ponta de seta ou polimarcador que será desenhado no vértice final da forma dada. 

Entrada:
  value: a ponta de seta ou polimarcador que será desenhado
    string: (e.g. "url(#triangle)")

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O final do marcador é renderizado apenas no vértice final dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-end pode ser usado como uma propriedade CSS.

func (*TagSvgView) MarkerMid 

func (e *TagSvgView) MarkerMid(value interface{}) (ref *TagSvgView)

MarkerMid

English:

The marker-mid attribute defines the arrowhead or polymarker that will be drawn at all interior vertices of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#circle)"

The marker is rendered on every vertex other than the first and last vertices of the path data.

Notes:

  • As a presentation attribute, marker-mid can be used as a CSS property.

Português:

O atributo marker-mid define a ponta de seta ou polimarcador que será desenhado em todos os vértices internos da forma dada. 

Input:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: ex. "url(#circle)"

O marcador é renderizado em todos os vértices, exceto no primeiro e no último vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o marker-mid pode ser usado como uma propriedade CSS.

func (*TagSvgView) MarkerStart 

func (e *TagSvgView) MarkerStart(value interface{}) (ref *TagSvgView)

MarkerStart

English:

The marker-start attribute defines the arrowhead or polymarker that will be drawn at the first vertex of the given shape. 

Input:
  value: defines the arrowhead or polymarker that will be drawn
    string: e.g. "url(#triangle)"

For all shape elements, except <polyline> and <path>, the last vertex is the same as the first vertex. In this case, if the value of marker-start and marker-end are both not none, then two markers will be rendered on that final vertex. For <path> elements, for each closed subpath, the last vertex is the same as the first vertex. marker-start is only rendered on the first vertex of the path data.

Notes:

  • As a presentation attribute, marker-start can be used as a CSS property.

Português:

O atributo marker-start define a ponta de seta ou polimarcador que será desenhado no primeiro vértice da forma dada. 

Entrada:
  value: define a ponta de seta ou polimarcador que será desenhado
    string: e.g. "url(#triangle)"

Para todos os elementos de forma, exceto <polyline> e <path>, o último vértice é o mesmo que o primeiro vértice. Nesse caso, se o valor de marker-start e marker-end não for nenhum, então dois marcadores serão renderizados nesse vértice final. Para elementos <path>, para cada subcaminho fechado, o último vértice é igual ao primeiro vértice. O início do marcador é renderizado apenas no primeiro vértice dos dados do caminho.

Notas:

  • Como atributo de apresentação, o início do marcador pode ser usado como uma propriedade CSS.

func (*TagSvgView) Mask 

func (e *TagSvgView) Mask(value interface{}) (ref *TagSvgView)

Mask

English:

The mask attribute is a presentation attribute mainly used to bind a given <mask> element with the element the attribute belongs to. 

Input:
  value: attribute mainly used to bind a given <mask> element
    string: "url(#myMask)"

Notes:

  • As a presentation attribute mask can be used as a CSS property.

Português:

O atributo mask é um atributo de apresentação usado principalmente para vincular um determinado elemento <mask> ao elemento ao qual o atributo pertence. 

Entrada:
  value: atributo usado principalmente para vincular um determinado elemento <mask>
    string: "url(#myMask)"

Notas:

  • Como uma máscara de atributo de apresentação pode ser usada como uma propriedade CSS.

func (*TagSvgView) Opacity 

func (e *TagSvgView) Opacity(value interface{}) (ref *TagSvgView)

Opacity

English:

The opacity attribute specifies the transparency of an object or of a group of objects, that is, the degree to which the background behind the element is overlaid. 

Input:
  value: specifies the transparency of an object
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute, opacity can be used as a CSS property. See the css opacity property for more
    information.

Português:

O atributo opacity especifica a transparência de um objeto ou de um grupo de objetos, ou seja, o grau em que o fundo atrás do elemento é sobreposto. 

Entrada:
  value: especifica a transparência de um objeto
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notes:
  * Como atributo de apresentação, a opacidade pode ser usada como uma propriedade CSS. Consulte a propriedade de
    opacidade do CSS para obter mais informações.

func (*TagSvgView) Overflow 

func (e *TagSvgView) Overflow(value interface{}) (ref *TagSvgView)

Overflow

English:

The overflow attribute sets what to do when an element's content is too big to fit in its block formatting context.

This attribute has the same parameter values and meaning as the css overflow property, however, the following additional points apply:

  • If it has a value of visible, the attribute has no effect (i.e., a clipping rectangle is not created).

  • If the overflow property has the value hidden or scroll, a clip of the exact size of the SVG viewport is applied.

  • When scroll is specified on an <svg> element, a scrollbar or panner is normally shown for the SVG viewport whether or not any of its content is clipped.

  • Within SVG content, the value auto implies that all rendered content for child elements must be visible, either through a scrolling mechanism, or by rendering with no clip.

    Notes:

  • Although the initial value for overflow is auto, it is overwritten in the User Agent style sheet for the <svg> element when it is not the root element of a stand-alone document, the <pattern> element, and the <marker> element to be hidden by default.

  • As a presentation attribute, overflow can be used as a CSS property. See the CSS overflow property for more information.

Português:

O atributo overflow define o que fazer quando o conteúdo de um elemento é muito grande para caber em seu contexto de formatação de bloco.

Este atributo tem os mesmos valores de parâmetro e significado que a propriedade CSS overflow, no entanto, os seguintes pontos adicionais se aplicam:

  • Se tiver um valor de visible, o atributo não terá efeito (ou seja, um retângulo de recorte não será criado).

  • Se a propriedade overflow tiver o valor oculto ou rolar, um clipe do tamanho exato da janela de visualização SVG será aplicado.

  • Quando a rolagem é especificada em um elemento <svg>, uma barra de rolagem ou panner normalmente é mostrado para a janela de visualização SVG, independentemente de seu conteúdo estar ou não recortado.

  • No conteúdo SVG, o valor auto implica que o conteúdo renderizado para elementos filho deve ser visível por completo, seja por meio de um mecanismo de rolagem ou renderizando sem clipe.

    Notas:

  • Embora o valor inicial para estouro seja auto, ele é substituído na folha de estilo do User Agent para o elemento <svg> quando não é o elemento raiz de um documento autônomo, o elemento <pattern> e o elemento <marker> para ser ocultado por padrão.

  • Como atributo de apresentação, overflow pode ser usado como propriedade CSS. Consulte a propriedade CSS overflow para obter mais informações.

func (*TagSvgView) PointerEvents 

func (e *TagSvgView) PointerEvents(value interface{}) (ref *TagSvgView)

PointerEvents

English:

The pointer-events attribute is a presentation attribute that allows defining whether or when an element may be the target of a mouse event. 

Notes:
  * As a presentation attribute pointer-events can be used as a CSS property.

Português:

O atributo pointer-events é um atributo de apresentação que permite definir se ou quando um elemento pode ser alvo de um evento de mouse. 

Notas:
  * Como um atributo de apresentação, os eventos de ponteiro podem ser usados como uma propriedade CSS.

func (*TagSvgView) PreserveAspectRatio 

func (e *TagSvgView) PreserveAspectRatio(ratio, meet interface{}) (ref *TagSvgView)

PreserveAspectRatio

English: 

The preserveAspectRatio attribute indicates how an element with a viewBox providing a given aspect ratio must fit
into a viewport with a different aspect ratio.

 Input:
   ratio: Indicates how an element with a viewBox providing a given aspect ratio.
     const: KRatio... (e.g. KRatioXMinYMin)
     any other type: interface{}
   meet: The meet or slice reference
     const: KMeetOrSliceReference... (e.g. KMeetOrSliceReferenceSlice)
     any other type: interface{}

Because the aspect ratio of an SVG image is defined by the viewBox attribute, if this attribute isn't set, the preserveAspectRatio attribute has no effect (with one exception, the <image> element, as described below).

Português: 

O atributo preserveAspectRatio indica como um elemento com uma viewBox fornecendo uma determinada proporção deve
caber em uma viewport com uma proporção diferente.

 Input:
   ratio: Indica como um elemento com uma viewBox fornece uma determinada proporção.
     const: KRatio... (ex. KRatioXMinYMin)
     qualquer outro tipo: interface{}
   meet: A referência de encontro ou fatia
     const: KMeetOrSliceReference... (ex. KMeetOrSliceReferenceSlice)
     qualquer outro tipo: interface{}

Como a proporção de uma imagem SVG é definida pelo atributo viewBox, se esse atributo não estiver definido, o atributo preserveAspectRatio não terá efeito (com uma exceção, o elemento <image>, conforme descrito abaixo).

func (*TagSvgView) ShapeRendering 

func (e *TagSvgView) ShapeRendering(value interface{}) (ref *TagSvgView)

ShapeRendering

English:

The shape-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering shapes like paths, circles, or rectangles. 

Input:
  value: provides hints to the renderer
    const: KSvgShapeRendering... (e.g. KShapeRenderingAuto)
    any other type: interface{}

Notes:
  * As a presentation attribute, shape-rendering can be used as a CSS property.

Português:

O atributo shape-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar formas como caminhos, círculos ou retângulos. 

Entrada:
  value: fornece dicas para o renderizador
    const: KSvgShapeRendering... (ex. KShapeRenderingAuto)
    any other type: interface{}

Notas:
  * Como um atributo de apresentação, a renderização de forma pode ser usada como uma propriedade CSS.

func (*TagSvgView) StopColor 

func (e *TagSvgView) StopColor(value interface{}) (ref *TagSvgView)

StopColor

English: 

The stop-color attribute indicates what color to use at a gradient stop.

 Input:
   value: indicates what color to use at a gradient stop
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notes:
   * With respect to gradients, SVG treats the transparent keyword differently than CSS. SVG does not calculate
     gradients in pre-multiplied space, so transparent really means transparent black. So, specifying a stop-color
     with the value transparent is equivalent to specifying a stop-color with the value black and a stop-opacity
     with the value 0.
   * As a presentation attribute, stop-color can be used as a CSS property.

Português: 

O atributo stop-color indica qual cor usar em uma parada de gradiente.

 Entrada:
   value: indica qual cor usar em um fim de gradiente
     string: e.g. "black"
     factory: e.g. factoryColor.NewYellow()
     RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}

 Notss:
   * Com relação aos gradientes, o SVG trata a palavra-chave transparente de maneira diferente do CSS. O SVG não
     calcula gradientes no espaço pré-multiplicado, portanto, transparente realmente significa preto transparente.
     Assim, especificar uma stop-color com o valor transparente é equivalente a especificar uma stop-color com o
     valor black e uma stop-opacity com o valor 0.
   * Como atributo de apresentação, stop-color pode ser usado como propriedade CSS.

func (*TagSvgView) StopOpacity 

func (e *TagSvgView) StopOpacity(value interface{}) (ref *TagSvgView)

StopOpacity

English:

The stop-opacity attribute defines the opacity of a given color gradient stop. 

Input:
  value: defines the opacity of a given color gradient stop
    float32: 1.0 = "100%"
    any other type: interface{}

The opacity value used for the gradient calculation is the product of the value of stop-opacity and the opacity of the value of the stop-color attribute. For stop-color values that don't include explicit opacity information, the opacity is treated as 1. 

Notes:
  * As a presentation attribute, stop-opacity can be used as a CSS property.

Português:

O atributo stop-opacity define a opacidade de uma determinada parada de gradiente de cor. 

Entrada:
  value: define a opacidade de uma determinada parada de gradiente de cor
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

O valor de opacidade usado para o cálculo do gradiente é o produto do valor de stop-opacity e a opacidade do valor do atributo stop-color. Para valores de stop-color que não incluem informações explícitas de opacidade, a opacidade é tratada como 1. 

Notas:
  * Como atributo de apresentação, stop-opacity pode ser usado como uma propriedade CSS.

func (*TagSvgView) Stroke 

func (e *TagSvgView) Stroke(value interface{}) (ref *TagSvgView)

Stroke

English:

The stroke attribute is a presentation attribute defining the color (or any SVG paint servers like gradients or patterns) used to paint the outline of the shape 

Input:
  value: presentation attribute defining the color
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

Notes:
  * As a presentation attribute stroke can be used as a CSS property.

Português:

O atributo de traço é um atributo de apresentação que define a cor (ou qualquer servidor de pintura SVG, como gradientes ou padrões) usado para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define a cor
    string: e.g. "black"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

Notas:
  * Como um traço de atributo de apresentação pode ser usado como uma propriedade CSS.

func (*TagSvgView) StrokeDasharray 

func (e *TagSvgView) StrokeDasharray(value interface{}) (ref *TagSvgView)

StrokeDasharray

English:

The stroke-dasharray attribute is a presentation attribute defining the pattern of dashes and gaps used to paint the outline of the shape 

Input:
  value: presentation attribute defining the pattern of dashes
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    any other type: interface{}

Notes:
  * As a presentation attribute, stroke-dasharray can be used as a CSS property.

Português:

O atributo stroke-dasharray é um atributo de apresentação que define o padrão de traços e lacunas usados para pintar o contorno da forma 

Entrada:
  value: atributo de apresentação que define o padrão de traços
    []float64: (e.g. []float64{4, 1, 2}) = "4 1 2"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o stroke-dasharray pode ser usado como uma propriedade CSS.

func (*TagSvgView) StrokeLineCap 

func (e *TagSvgView) StrokeLineCap(value interface{}) (ref *TagSvgView)

StrokeLineCap

English:

The stroke-linecap attribute is a presentation attribute defining the shape to be used at the end of open subpaths when they are stroked. 

Input:
  value: presentation attribute defining the shape to be used at the end of open subpaths
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-linecap can be used as a CSS property.

Português:

O atributo stroke-linecap é um atributo de apresentação que define a forma a ser usada no final de subcaminhos abertos quando eles são traçados. 

Input:
  value: atributo de apresentação que define a forma a ser usada no final de subcaminhos
    const: KSvgStrokeLinecap... (e.g. KSvgStrokeLinecapRound)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o traço-linecap pode ser usado como uma propriedade CSS.

func (*TagSvgView) StrokeLineJoin 

func (e *TagSvgView) StrokeLineJoin(value interface{}) (ref *TagSvgView)

StrokeLineJoin

English:

The stroke-linejoin attribute is a presentation attribute defining the shape to be used at the corners of paths when they are stroked. 

Notes:
  * As a presentation attribute stroke-linejoin can be used as a CSS property.

Português:

O atributo stroke-linejoin é um atributo de apresentação que define a forma a ser usada nos cantos dos caminhos quando eles são traçados. 

Notas:
  * Como atributo de apresentação, stroke-linejoin pode ser usado como propriedade CSS.

func (*TagSvgView) StrokeMiterLimit 

func (e *TagSvgView) StrokeMiterLimit(value float64) (ref *TagSvgView)

StrokeMiterLimit

English:

The stroke-miterlimit attribute is a presentation attribute defining a limit on the ratio of the miter length to the stroke-width used to draw a miter join. When the limit is exceeded, the join is converted from a miter to a bevel. 

Notes:
  * As a presentation attribute stroke-miterlimit can be used as a CSS property.

Português:

O atributo stroke-miterlimit é um atributo de apresentação que define um limite na proporção do comprimento da mitra para a largura do traço usado para desenhar uma junção de mitra. Quando o limite é excedido, a junção é convertida de uma mitra para um chanfro. 

Notas:
  * Como atributo de apresentação, stroke-miterlimit pode ser usado como propriedade CSS.

func (*TagSvgView) StrokeOpacity 

func (e *TagSvgView) StrokeOpacity(value interface{}) (ref *TagSvgView)

StrokeOpacity

English:

The stroke-opacity attribute is a presentation attribute defining the opacity of the paint server (color, gradient, pattern, etc) applied to the stroke of a shape. 

Input:
  value: defining the opacity of the paint
    float32: 1.0 = "100%"
    any other type: interface{}

Notes:
  * As a presentation attribute stroke-opacity can be used as a CSS property.

Português:

O atributo de opacidade do traçado é um atributo de apresentação que define a opacidade do servidor de pintura (cor, gradiente, padrão etc.) aplicado ao traçado de uma forma. 

Entrada:
  value: definindo a opacidade da tinta
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, a opacidade do traço pode ser usada como uma propriedade CSS.

func (*TagSvgView) StrokeWidth 

func (e *TagSvgView) StrokeWidth(value interface{}) (ref *TagSvgView)

StrokeWidth

English:

The stroke-width attribute is a presentation attribute defining the width of the stroke to be applied to the shape. 

Input:
  value: defining the width of the stroke
    float32: 1.0 = "100%"
    any other type: interface{}

Português:

O atributo stroke-width é um atributo de apresentação que define a largura do traço a ser aplicado à forma. 

Entrada:
  value: definindo a largura do traço
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

func (*TagSvgView) Style 

func (e *TagSvgView) Style(value string) (ref *TagSvgView)

Style

English:

The style attribute allows to style an element using CSS declarations. It functions identically to the style attribute in HTML.

Português:

O atributo style permite estilizar um elemento usando declarações CSS. Funciona de forma idêntica ao atributo style em HTML.

func (*TagSvgView) Tabindex 

func (e *TagSvgView) Tabindex(value int) (ref *TagSvgView)

Tabindex

English:

The tabindex attribute allows you to control whether an element is focusable and to define the relative order of the element for the purposes of sequential focus navigation.

Português:

O atributo tabindex permite controlar se um elemento é focalizável e definir a ordem relativa do elemento para fins de navegação de foco sequencial.

func (*TagSvgView) Text 

func (e *TagSvgView) Text(value string) (ref *TagSvgView)

Text

English:

Adds plain text to the tag's content.

Text:

Adiciona um texto simples ao conteúdo da tag.

func (*TagSvgView) TextAnchor 

func (e *TagSvgView) TextAnchor(value interface{}) (ref *TagSvgView)

TextAnchor

English:

The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of pre-formatted text or auto-wrapped text where the wrapping area is determined from the inline-size property relative to a given point. 

Input:
  value: used to align a string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    any other type: interface{}

This attribute is not applicable to other types of auto-wrapped text. For those cases you should use text-align. For multi-line text, the alignment takes place for each line.

The text-anchor attribute is applied to each individual text chunk within a given <text> element. Each text chunk has an initial current text position, which represents the point in the user coordinate system resulting from (depending on context) application of the x and y attributes on the <text> element, any x or y attribute values on a <tspan>, <tref> or <altGlyph> element assigned explicitly to the first rendered character in a text chunk, or determination of the initial current text position for a <textPath> element. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

Português:

O atributo text-anchor é usado para alinhar (alinhamento inicial, intermediário ou final) uma string de texto pré-formatado ou texto com quebra automática onde a área de quebra é determinada a partir da propriedade inline-size relativa a um determinado ponto. 

Entrada:
  value: usado para alinhar uma string
    const: KSvgTextAnchor... (e.g. KSvgTextAnchorStart)
    qualquer outro tipo: interface{}

Este atributo não se aplica a outros tipos de texto com quebra automática. Para esses casos, você deve usar text-align. Para texto de várias linhas, o alinhamento ocorre para cada linha.

O atributo text-anchor é aplicado a cada fragmento de texto individual dentro de um determinado elemento <text>. Cada pedaço de texto tem uma posição inicial de texto atual, que representa o ponto no sistema de coordenadas do usuário resultante (dependendo do contexto) da aplicação dos atributos x e y no elemento <text>, quaisquer valores de atributo x ou y em um <tspan >, elemento <tref> ou <altGlyph> atribuído explicitamente ao primeiro caractere renderizado em um pedaço de texto, ou determinação da posição inicial do texto atual para um elemento <textPath>. 

Notes:
  * As a presentation attribute, text-anchor can be used as a CSS property.

func (*TagSvgView) TextDecoration 

func (e *TagSvgView) TextDecoration(value interface{}) (ref *TagSvgView)

TextDecoration

English:

The text-decoration attribute defines whether text is decorated with an underline, overline and/or strike-through. It is a shorthand for the text-decoration-line and text-decoration-style properties. 

Input:
  value: defines whether text is decorated
    const: KSvgTextDecorationLine... (e.g. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (e.g. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    any other type: interface{}

The fill and stroke of the text decoration are given by the fill and stroke of the text at the point where the text decoration is declared.

The paint order of the text decoration, i.e. the fill and stroke, is determined by the value of the paint-order attribute at the point where the text decoration is declared. 

Notes:
  * As a presentation attribute, text-decoration can be used as a CSS property. See the css text-decoration
    property for more information.

Português:

O atributo text-decoration define se o texto é decorado com sublinhado, overline e ou tachado. É um atalho para as propriedades text-decoration-line e text-decoration-style. 

Entrada:
  value: define se o texto é decorado
    const: KSvgTextDecorationLine... (ex. KSvgTextDecorationLineUnderline)
    const: KSvgTextDecorationStyle... (ex. KSvgTextDecorationStyleDouble)
    string: e.g. "black", "line-through"
    factory: e.g. factoryColor.NewYellow()
    RGBA: e.g. color.RGBA{R: 0xff, G: 0xff, B: 0x00, A: 0xff}
    qualquer outro tipo: interface{}

O preenchimento e o traçado da decoração de texto são dados pelo preenchimento e traçado do texto no ponto em que a decoração de texto é declarada.

A ordem de pintura da decoração do texto, ou seja, o preenchimento e o traço, é determinada pelo valor do atributo paint-order no ponto em que a decoração do texto é declarada. 

Notas:
  * Como atributo de apresentação, a decoração de texto pode ser usada como uma propriedade CSS. Consulte a
    propriedade CSS text-decoration para obter mais informações.

func (*TagSvgView) TextRendering 

func (e *TagSvgView) TextRendering(value interface{}) (ref *TagSvgView)

TextRendering

English:

The text-rendering attribute provides hints to the renderer about what tradeoffs to make when rendering text. 

Notes:
  * As a presentation attribute, text-rendering can be used as a CSS property.
    See the css text-rendering property for more information.

Português:

O atributo text-rendering fornece dicas ao renderizador sobre quais compensações fazer ao renderizar o texto. 

Notas:
  * Como um atributo de apresentação, a renderização de texto pode ser usada como uma propriedade CSS.
    Consulte a propriedade de renderização de texto css para obter mais informações.

func (*TagSvgView) Transform 

func (e *TagSvgView) Transform(value interface{}) (ref *TagSvgView)

Transform

English:

The transform attribute defines a list of transform definitions that are applied to an element and the element's children. 

Input:
  value: defines a list of transform definitions
    *TransformFunctions: todo: documentar
    TransformFunctions:
    any other type: interface{}

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

O atributo transform define uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Entrada:
  value: define uma lista de definições de transformação
    *TransformFunctions: todo: documentar
    TransformFunctions:
    qualquer outro tipo: interface{}

Notas:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TagSvgView) UnicodeBidi 

func (e *TagSvgView) UnicodeBidi(value interface{}) (ref *TagSvgView)

UnicodeBidi

English:

The unicode-bidi attribute specifies how the accumulation of the background image is managed. 

Input:
  value: specifies how the accumulation of the background image is managed
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    any other type: interface{}

Notes:
  * As a presentation attribute, unicode-bidi can be used as a CSS property. See the CSS unicode-bidi property for
    more information.

Português:

O atributo unicode-bidi especifica como o acúmulo da imagem de fundo é gerenciado. 

Entrada:
  value: especifica como o acúmulo da imagem de fundo é gerenciado
    const: KSvgTransformOrigin... (e.g. KSvgTransformOriginLeft)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o unicode-bidi pode ser usado como uma propriedade CSS. Consulte a propriedade
    CSS unicode-bidi para obter mais informações.

func (*TagSvgView) VectorEffect 

func (e *TagSvgView) VectorEffect(value interface{}) (ref *TagSvgView)

VectorEffect

English:

The vector-effect property specifies the vector effect to use when drawing an object. 

Input:
  value: specifies the vector effect
    const: KSvgVectorEffect... (e.g. KSvgVectorEffectNonScalingStroke)

Vector effects are applied before any of the other compositing operations, i.e. filters, masks and clips. 

Notes:
  * As a presentation attribute, vector-effect can be used as a CSS property.

Português:

A propriedade vector-effect especifica o efeito vetorial a ser usado ao desenhar um objeto. 

Entrada:
  value: especifica o efeito vetorial
    const: KSvgVectorEffect... (ex. KSvgVectorEffectNonScalingStroke)

Os efeitos vetoriais são aplicados antes de qualquer outra operação de composição, ou seja, filtros, máscaras e clipes. 

Notas:
  * Como atributo de apresentação, o efeito vetorial pode ser usado como uma propriedade CSS.

func (*TagSvgView) ViewBox 

func (e *TagSvgView) ViewBox(value interface{}) (ref *TagSvgView)

ViewBox

English:

The viewBox attribute defines the position and dimension, in user space, of an SVG viewport. 

Input:
  value: defines the position and dimension, in user space, of an SVG viewport
    []float64: ex. []float64{0.0, 0.0, 10.0, 10.0} = "0 0 10 10"
    any other type: interface{}

The value of the viewBox attribute is a list of four numbers: min-x, min-y, width and height. The numbers, which are separated by whitespace and/or a comma, specify a rectangle in user space which is mapped to the bounds of the viewport established for the associated SVG element (not the browser viewport).

Português:

O atributo viewBox define a posição e a dimensão, no espaço do usuário, de uma viewport SVG. 

Input:
  value: define a posição e dimensão, no espaço do usuário, de uma viewport SVG
    []float64: ex. []float64{0.0, 0.0, 10.0, 10.0} = "0 0 10 10"
    qualquer outro tipo: interface{}

O valor do atributo viewBox é uma lista de quatro números: min-x, min-y, largura e altura. Os números, que são separados por espaço em branco e ou vírgula, especificam um retângulo no espaço do usuário que é mapeado para os limites da janela de visualização estabelecida para o elemento SVG associado (não a janela de visualização do navegador).

func (*TagSvgView) Visibility 

func (e *TagSvgView) Visibility(value interface{}) (ref *TagSvgView)

Visibility

English:

The visibility attribute lets you control the visibility of graphical elements. 

Input:
  value: lets you control the visibility
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    any other type: interface{}

With a value of hidden or collapse the current graphics element is invisible.

Depending on the value of attribute pointer-events, graphics elements which have their visibility attribute set to hidden still might receive events. 

Notes:
  * If the visibility attribute is set to hidden on a text element, then the text is invisible but still takes up
    space in text layout calculations;
  * As a presentation attribute, visibility can be used as a CSS property. See the css visibility property for
    more information.

Português:

O atributo de visibilidade permite controlar a visibilidade dos elementos gráficos. 

Entrada:
  value: permite controlar a visibilidade
    const: KSvgVisibility... (e.g. KSvgVisibilityHidden)
    qualquer outro tipo: interface{}

Com um valor oculto ou recolhido, o elemento gráfico atual fica invisível.

Dependendo do valor do atributo pointer-events, os elementos gráficos que têm seu atributo de visibilidade definido como oculto ainda podem receber eventos. 

Notas:
  * Se o atributo de visibilidade estiver definido como oculto em um elemento de texto, o texto ficará invisível,
    mas ainda ocupará espaço nos cálculos de layout de texto;
  * Como atributo de apresentação, a visibilidade pode ser usada como propriedade CSS. Consulte a propriedade de
    visibilidade do CSS para obter mais informações.

func (*TagSvgView) WordSpacing 

func (e *TagSvgView) WordSpacing(value interface{}) (ref *TagSvgView)

WordSpacing

English:

The word-spacing attribute specifies spacing behavior between words. 

Input:
  value: specifies spacing behavior between words
    float32: 1.0 = "100%"
    any other type: interface{}

If a <length> is provided without a unit identifier (e.g. an unqualified number such as 128), the browser processes the <length> as a width value in the current user coordinate system.

If a <length> is provided with one of the unit identifiers (e.g. .25em or 1%), then the browser converts the <length> into a corresponding value in the current user coordinate system. 

Notes:
  * As a presentation attribute, word-spacing can be used as a CSS property. See the css word-spacing property for
    more information.

Português:

O atributo word-spacing especifica o comportamento do espaçamento entre as palavras. 

Entrada:
  value: especifica o comportamento de espaçamento entre palavras
    float32: 1.0 = "100%"
    qualquer outro tipo: interface{}

Se um <comprimento> for fornecido sem um identificador de unidade (por exemplo, um número não qualificado como 128), o navegador processará o <comprimento> como um valor de largura no sistema de coordenadas do usuário atual.

Se um <comprimento> for fornecido com um dos identificadores de unidade (por exemplo, .25em ou 1%), o navegador converterá o <comprimento> em um valor correspondente no sistema de coordenadas do usuário atual. 

Notas:
  * Como atributo de apresentação, o espaçamento entre palavras pode ser usado como uma propriedade CSS.
    Consulte a propriedade de espaçamento entre palavras do CSS para obter mais informações.

func (*TagSvgView) WritingMode 

func (e *TagSvgView) WritingMode(value interface{}) (ref *TagSvgView)

WritingMode

English:

The writing-mode attribute specifies whether the initial inline-progression-direction for a <text> element shall be left-to-right, right-to-left, or top-to-bottom. The writing-mode attribute applies only to <text> elements; the attribute is ignored for <tspan>, <tref>, <altGlyph> and <textPath> sub-elements. (Note that the inline-progression-direction can change within a <text> element due to the Unicode bidirectional algorithm and properties direction and unicode-bidi.) 

Input:
  value: specifies whether the initial inline-progression-direction
    const: KSvgWritingMode... (e.g. KSvgWritingModeHorizontalTb)
    any other type: interface{}

Notes:
  * As a presentation attribute, writing-mode can be used as a CSS property. See the CSS writing-mode property for
    more information.

Português:

O atributo write-mode especifica se a direção de progressão inline inicial para um elemento <text> deve ser da esquerda para a direita, da direita para a esquerda ou de cima para baixo. O atributo write-mode aplica-se apenas a elementos <text>; o atributo é ignorado para os subelementos <tspan>, <tref>, <altGlyph> e <textPath>. (Observe que a direção de progressão em linha pode mudar dentro de um elemento <text> devido ao algoritmo bidirecional Unicode e direção de propriedades e unicode-bidi.) 

Entrada:
  value: especifica se a direção de progressão em linha inicial
    const: KSvgWritingMode... (ex. KSvgWritingModeHorizontalTb)
    qualquer outro tipo: interface{}

Notas:
  * Como atributo de apresentação, o modo de escrita pode ser usado como uma propriedade CSS. Consulte a
    propriedade do modo de gravação CSS para obter mais informações.

func (*TagSvgView) XmlLang 

func (e *TagSvgView) XmlLang(value interface{}) (ref *TagSvgView)

XmlLang

English:

The xml:lang attribute specifies the primary language used in contents and attributes containing text content of particular elements. 

Input:
  value: specifies the primary language
    const: KLanguage... (e.g. KLanguageEnglish)
    any other type: interface{}

It is a universal attribute allowed in all XML dialects to mark up the natural human language that an element contains.

There is also a lang attribute (without namespace). If both of them are defined, the one with namespace is used and the one without is ignored.

Português:

O atributo xml:lang especifica o idioma principal usado em conteúdos e atributos que contêm conteúdo de texto de elementos específicos. 

Entrada:
  value: especifica o idioma principal
    const: KLanguage... (e.g. KLanguagePortuguese)
    qualquer outro tipo: interface{}

É um atributo universal permitido em todos os dialetos XML para marcar a linguagem humana natural que um elemento contém.

Há também um atributo lang (sem namespace). Se ambos estiverem definidos, aquele com namespace será usado e o sem namespace será ignorado.

type TagTextArea 

type TagTextArea struct {
	// contains filtered or unexported fields
}

func (*TagTextArea) AccessKey 

func (e *TagTextArea) AccessKey(key string) (ref *TagTextArea)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagTextArea) Append 

func (e *TagTextArea) Append(append interface{}) (ref *TagTextArea)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagTextArea) AppendById 

func (e *TagTextArea) AppendById(appendId string) (ref *TagTextArea)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagTextArea) Autocomplete 

func (e *TagTextArea) Autocomplete(autocomplete Autocomplete) (ref *TagTextArea)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagTextArea) Autofocus 

func (e *TagTextArea) Autofocus(autofocus bool) (ref *TagTextArea)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagTextArea) Class 

func (e *TagTextArea) Class(class ...string) (ref *TagTextArea)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagTextArea) Cols 

func (e *TagTextArea) Cols(cols int) (ref *TagTextArea)

Cols

English: 

The visible width of the text control, in average character widths.

 Note:
   * If it is not specified, the default value is 20;
   * If it is specified, it must be a positive integer.

Português: 

A largura visível do controle de texto, em larguras médias de caracteres.

 Note:
   * Se não for especificado, o valor padrão é 20;
   * Se for especificado, deve ser um número inteiro positivo.

func (*TagTextArea) ContentEditable 

func (e *TagTextArea) ContentEditable(editable bool) (ref *TagTextArea)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagTextArea) CreateElement 

func (e *TagTextArea) CreateElement(tag Tag) (ref *TagTextArea)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagTextArea) Data 

func (e *TagTextArea) Data(data map[string]string) (ref *TagTextArea)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagTextArea) Dir 

func (e *TagTextArea) Dir(dir Dir) (ref *TagTextArea)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagTextArea) Disabled 

func (e *TagTextArea) Disabled(disabled bool) (ref *TagTextArea)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagTextArea) Draggable 

func (e *TagTextArea) Draggable(draggable Draggable) (ref *TagTextArea)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagTextArea) EnterKeyHint 

func (e *TagTextArea) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagTextArea)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagTextArea) Form 

func (e *TagTextArea) Form(form string) (ref *TagTextArea)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagTextArea) GetX 

func (e *TagTextArea) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagTextArea) GetXY 

func (e *TagTextArea) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagTextArea) GetY 

func (e *TagTextArea) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagTextArea) Hidden 

func (e *TagTextArea) Hidden() (ref *TagTextArea)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagTextArea) Id 

func (e *TagTextArea) Id(id string) (ref *TagTextArea)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagTextArea) InputMode 

func (e *TagTextArea) InputMode(inputMode InputMode) (ref *TagTextArea)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagTextArea) Is 

func (e *TagTextArea) Is(is string) (ref *TagTextArea)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagTextArea) ItemDrop 

func (e *TagTextArea) ItemDrop(itemprop string) (ref *TagTextArea)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagTextArea) ItemId 

func (e *TagTextArea) ItemId(id string) (ref *TagTextArea)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagTextArea) ItemRef 

func (e *TagTextArea) ItemRef(itemref string) (ref *TagTextArea)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagTextArea) ItemType 

func (e *TagTextArea) ItemType(itemType string) (ref *TagTextArea)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagTextArea) Lang 

func (e *TagTextArea) Lang(language Language) (ref *TagTextArea)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagTextArea) MaxLength 

func (e *TagTextArea) MaxLength(maxlength int) (ref *TagTextArea)

MaxLength

English: 

The maximum number of characters (UTF-16 code units) that the user can enter.

 Note:
   * If this value isn't specified, the user can enter an unlimited number of characters.

Português: 

O número máximo de caracteres (unidades de código UTF-16) que o usuário pode inserir.

 Nota:
   * Se esse valor não for especificado, o usuário poderá inserir um número ilimitado de
     caracteres.

func (*TagTextArea) MinLength 

func (e *TagTextArea) MinLength(maxlength int) (ref *TagTextArea)

MinLength

English: 

The minimum number of characters (UTF-16 code units) required that the user should enter.

Português: 

O número mínimo de caracteres (unidades de código UTF-16) que o usuário pode inserir.

func (*TagTextArea) Nonce 

func (e *TagTextArea) Nonce(part ...string) (ref *TagTextArea)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagTextArea) Placeholder 

func (e *TagTextArea) Placeholder(placeholder string) (ref *TagTextArea)

Placeholder

English: 

The placeholder attribute is a string that provides a brief hint to the user as to what kind of
information is expected in the field. It should be a word or short phrase that provides a hint
as to the expected type of data, rather than an explanation or prompt. The text must not include
carriage returns or line feeds. So for example if a field is expected to capture a user's first
name, and its label is "First Name", a suitable placeholder might be "e.g. Mustafa".

 Note:
   * The placeholder attribute is not as semantically useful as other ways to explain your form,
     and can cause unexpected technical issues with your content. See Labels for more information.

Português: 

O atributo placeholder é uma string que fornece uma breve dica ao usuário sobre que tipo de
informação é esperada no campo. Deve ser uma palavra ou frase curta que forneça uma dica sobre o
tipo de dados esperado, em vez de uma explicação ou prompt. O texto não deve incluir retornos de
carro ou feeds de linha. Assim, por exemplo, se espera-se que um campo capture o primeiro nome de
um usuário e seu rótulo for "Nome", um espaço reservado adequado pode ser "por exemplo, Mustafa".

 Nota:
   * O atributo placeholder não é tão semanticamente útil quanto outras formas de explicar seu
     formulário e pode causar problemas técnicos inesperados com seu conteúdo. Consulte Rótulos
     para obter mais informações.

func (*TagTextArea) ReadOnly 

func (e *TagTextArea) ReadOnly(readonly bool) (ref *TagTextArea)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

Português: 

Um atributo booleano que, se presente, indica que o usuário não deve poder editar o valor da
entrada.

func (*TagTextArea) Required 

func (e *TagTextArea) Required(required bool) (ref *TagTextArea)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagTextArea) Rows 

func (e *TagTextArea) Rows(rows int) (ref *TagTextArea)

Rows

English:

The number of visible text lines for the control. 

Note:
  * If it is specified, it must be a positive integer;
  * If it is not specified, the default value is 2.

Português:

O número de linhas de texto visíveis para o controle. 

Nota:
  * Se for especificado, deve ser um número inteiro positivo;
  * Se não for especificado, o valor padrão é 2.

func (*TagTextArea) SetName 

func (e *TagTextArea) SetName(name string) (ref *TagTextArea)

SetName

English: 

O nome do elemento enviado.

Português: 

O nome do elemento enviado.

func (*TagTextArea) SetX 

func (e *TagTextArea) SetX(x int) (ref *TagTextArea)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagTextArea) SetXY 

func (e *TagTextArea) SetXY(x, y int) (ref *TagTextArea)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagTextArea) SetY 

func (e *TagTextArea) SetY(y int) (ref *TagTextArea)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagTextArea) Slot 

func (e *TagTextArea) Slot(slot string) (ref *TagTextArea)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagTextArea) Spellcheck 

func (e *TagTextArea) Spellcheck(spell bool) (ref *TagTextArea)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagTextArea) Style 

func (e *TagTextArea) Style(style string) (ref *TagTextArea)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagTextArea) TabIndex 

func (e *TagTextArea) TabIndex(index int) (ref *TagTextArea)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagTextArea) Title 

func (e *TagTextArea) Title(title string) (ref *TagTextArea)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagTextArea) Translate 

func (e *TagTextArea) Translate(translate Translate) (ref *TagTextArea)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagTextArea) Warp 

func (e *TagTextArea) Warp(warp Warp) (ref *TagTextArea)

Warp

English: 

Indicates how the control wraps text.

Português: 

Indica como o controle quebra o texto.

type Target 

type Target string
const (
	// KTargetSelf
	//
	// English:
	//
	//  The current browsing context; (default)
	//
	// Português:
	//
	//  O contexto de navegação atual; (padrão)
	//
	KTargetSelf Target = "_self"

	// KTargetBlank
	//
	// English:
	//
	//  Usually a new tab, but users can configure browsers to open a new window instead;
	//
	// Português:
	//
	//  Normalmente, uma nova guia, mas os usuários podem configurar os navegadores para abrir uma nova
	//  janela;
	//
	KTargetBlank Target = "_blank"

	// KTargetParent
	//
	// English:
	//
	//  The parent browsing context of the current one. If no parent, behaves as _self;
	//
	// Português:
	//
	//  O contexto de navegação pai do atual. Se nenhum pai, se comporta como _self;
	//
	KTargetParent Target = "_parent"

	// KTargetTop
	//
	// English:
	//
	//  The topmost browsing context (the "highest" context that's an ancestor of the current one).
	//  If no ancestors, behaves as _self.
	//
	// Português:
	//
	//  O contexto de navegação mais alto (o contexto "mais alto" que é um ancestral do atual).
	//  Se não houver ancestrais, se comporta como _self.
	//
	KTargetTop Target = "_top"
)

func (Target) String 

func (e Target) String() string

type TextBaseLineRule 

type TextBaseLineRule string
const (
	// KTextBaseLineRuleAlphabetic
	//
	// English:
	//
	//  (Default) The text baseline is the normal alphabetic baseline.
	//
	// Português:
	//
	//  (Padrão) A linha de base do texto é a linha de base alfabética normal.
	KTextBaseLineRuleAlphabetic TextBaseLineRule = "alphabetic"

	// KTextBaseLineRuleTop
	//
	// English:
	//
	//  The text baseline is the top of the em square.
	//
	// Português:
	//
	//  A linha de base do texto é a parte superior do quadrado em.
	KTextBaseLineRuleTop TextBaseLineRule = "top"

	// KTextBaseLineRuleHanging
	//
	// English:
	//
	//  The text baseline is the hanging baseline.
	//
	// Português:
	//
	//  A linha de base do texto é a linha de base suspensa.
	KTextBaseLineRuleHanging TextBaseLineRule = "hanging"

	// KTextBaseLineRuleMiddle
	//
	// English:
	//
	//  The text baseline is the middle of the em square.
	//
	// Português:
	//
	//  A linha de base do texto é o meio do quadrado em.
	KTextBaseLineRuleMiddle TextBaseLineRule = "middle"

	// KTextBaseLineRuleIdeographic
	//
	// English:
	//
	//  The text baseline is the ideographic baseline.
	//
	// Português:
	//
	//  The text baseline is the ideographic baseline.
	KTextBaseLineRuleIdeographic TextBaseLineRule = "ideographic"

	// KTextBaseLineRuleBottom
	//
	// English:
	//
	//  The text baseline is the bottom of the bounding box.
	//
	// Português:
	//
	//  A linha de base do texto é a parte inferior da caixa delimitadora.
	KTextBaseLineRuleBottom TextBaseLineRule = "bottom"
)

func (TextBaseLineRule) String 

func (e TextBaseLineRule) String() string

type TransformFunctions 

type TransformFunctions struct {
	// contains filtered or unexported fields
}

TransformFunctions

English:

The transform functions defines a list of transform definitions that are applied to an element and the element's children. 

Notes:
  * As of SVG2, transform is a presentation attribute, meaning it can be used as a CSS property. However, be aware
    that there are some differences in syntax between the CSS property and the attribute. See the documentation for
    the CSS property transform for the specific syntax to use in that case.

Português:

As funções de transformação definem uma lista de definições de transformação que são aplicadas a um elemento e aos filhos do elemento. 

Notes:
  * A partir do SVG2, transform é um atributo de apresentação, o que significa que pode ser usado como uma
    propriedade CSS. No entanto, esteja ciente de que existem algumas diferenças na sintaxe entre a propriedade CSS
    e o atributo. Consulte a documentação da transformação da propriedade CSS para obter a sintaxe específica a ser
    usada nesse caso.

func (*TransformFunctions) Matrix 

func (el *TransformFunctions) Matrix(a, b, c, d, e, f float64) (ref *TransformFunctions)

Matrix

English:

The matrix(<a> <b> <c> <d> <e> <f>) transform function specifies a transformation in the form of a transformation matrix of six values. matrix(a,b,c,d,e,f) is equivalent to applying the transformation matrix: 

  a c e
( b d f )
  0 0 1

which maps coordinates from a previous coordinate system into a new coordinate system by the following matrix equalities: 

  x_newCoordSys       a c e       x_prevCoordSys       a*x_prevCoordSys + c*y_prevCoordSys + e
( y_newCoordSys ) = ( b d f )   ( y_prevCoordSys )   ( b*x_prevCoordSys + d*y_prevCoordSys + f )
       1              0 0 1             1                                 1

Example:
  <svg viewBox="0 0 200 200" xmlns="http://www.w3.org/2000/svg">
    <rect x="10" y="10" width="30" height="20" fill="green" />

    <!--
    In the following example we are applying the matrix:
    [a c e]    [3 -1 30]
    [b d f] => [1  3 40]
    [0 0 1]    [0  0  1]

    which transform the rectangle as such:

    top left corner: oldX=10 oldY=10
    newX = a * oldX + c * oldY + e = 3 * 10 - 1 * 10 + 30 = 50
    newY = b * oldX + d * oldY + f = 1 * 10 + 3 * 10 + 40 = 80

    top right corner: oldX=40 oldY=10
    newX = a * oldX + c * oldY + e = 3 * 40 - 1 * 10 + 30 = 140
    newY = b * oldX + d * oldY + f = 1 * 40 + 3 * 10 + 40 = 110

    bottom left corner: oldX=10 oldY=30
    newX = a * oldX + c * oldY + e = 3 * 10 - 1 * 30 + 30 = 30
    newY = b * oldX + d * oldY + f = 1 * 10 + 3 * 30 + 40 = 140

    bottom right corner: oldX=40 oldY=30
    newX = a * oldX + c * oldY + e = 3 * 40 - 1 * 30 + 30 = 120
    newY = b * oldX + d * oldY + f = 1 * 40 + 3 * 30 + 40 = 170
    -->
    <rect x="10" y="10" width="30" height="20" fill="red" transform="matrix(3 1 -1 3 30 40)" />
  </svg>

Português:

A função de transformação matrix(<a> <b> <c> <d> <e> <f>) especifica uma transformação na forma de uma matriz de transformação de seis valores. matrix(a,b,c,d,e,f) é equivalente a aplicar a matriz de transformação: 

  a c e
( b d f )
  0 0 1

que mapeia as coordenadas de um sistema de coordenadas anterior em um novo sistema de coordenadas pelas seguintes igualdades de matriz: 

  x_newCoordSys       a c e       x_prevCoordSys       a*x_prevCoordSys + c*y_prevCoordSys + e
( y_newCoordSys ) = ( b d f )   ( y_prevCoordSys )   ( b*x_prevCoordSys + d*y_prevCoordSys + f )
       1              0 0 1             1                                 1

Example:
  <svg viewBox="0 0 200 200" xmlns="http://www.w3.org/2000/svg">
    <rect x="10" y="10" width="30" height="20" fill="green" />

    <!--
    In the following example we are applying the matrix:
    [a c e]    [3 -1 30]
    [b d f] => [1  3 40]
    [0 0 1]    [0  0  1]

    which transform the rectangle as such:

    top left corner: oldX=10 oldY=10
    newX = a * oldX + c * oldY + e = 3 * 10 - 1 * 10 + 30 = 50
    newY = b * oldX + d * oldY + f = 1 * 10 + 3 * 10 + 40 = 80

    top right corner: oldX=40 oldY=10
    newX = a * oldX + c * oldY + e = 3 * 40 - 1 * 10 + 30 = 140
    newY = b * oldX + d * oldY + f = 1 * 40 + 3 * 10 + 40 = 110

    bottom left corner: oldX=10 oldY=30
    newX = a * oldX + c * oldY + e = 3 * 10 - 1 * 30 + 30 = 30
    newY = b * oldX + d * oldY + f = 1 * 10 + 3 * 30 + 40 = 140

    bottom right corner: oldX=40 oldY=30
    newX = a * oldX + c * oldY + e = 3 * 40 - 1 * 30 + 30 = 120
    newY = b * oldX + d * oldY + f = 1 * 40 + 3 * 30 + 40 = 170
    -->
    <rect x="10" y="10" width="30" height="20" fill="red" transform="matrix(3 1 -1 3 30 40)" />
  </svg>

func (*TransformFunctions) Rotate 

func (el *TransformFunctions) Rotate(a, x, y float64) (ref *TransformFunctions)

Rotate

English:

The rotate(<a>) transform function specifies a rotation by a degrees about a given point.

The rotation is about the point (x, y).

Português:

A função de transformação rotate(<a>) especifica uma rotação de um grau em torno de um determinado ponto.

A rotação é em torno do ponto (x, y).

func (*TransformFunctions) RotateAngle 

func (el *TransformFunctions) RotateAngle(a float64) (ref *TransformFunctions)

RotateAngle

English:

The rotate(<a>) transform function specifies a rotation by a degrees about a given point.

The rotation is about the origin of the current user coordinate system.

Português:

A função de transformação rotate(<a>) especifica uma rotação de um grau em torno de um determinado ponto.

A rotação é sobre a origem do sistema de coordenadas do usuário atual.

func (*TransformFunctions) RotateAngleXCoord 

func (el *TransformFunctions) RotateAngleXCoord(a, x float64) (ref *TransformFunctions)

RotateAngleXCoord

English:

The rotate(<a>) transform function specifies a rotation by a degrees about a given point.

The rotation is about the supplied x and the origin of the current point y.

Português:

A função de transformação rotate(<a>) especifica uma rotação de um grau em torno de um determinado ponto.

A rotação é sobre o x fornecido e a origem do ponto atual y.

func (*TransformFunctions) Scale 

func (el *TransformFunctions) Scale(x, y float64) (ref *TransformFunctions)

Scale

English:

The scale(<x> [<y>]) transform function specifies a scale operation by x and y. If y is not provided, it is assumed to be equal to x.

Português:

A função de transformação scale(<x> [<y>]) especifica uma operação de escala por x e y. Se y não for fornecido, assume-se que é igual a x.

func (*TransformFunctions) SkewX 

func (el *TransformFunctions) SkewX(a float64) (ref *TransformFunctions)

SkewX

English:

The skewX(<a>) transform function specifies a skew transformation along the x axis by a degrees.

Português:

A função de transformação skewX(<a>) especifica uma transformação de inclinação ao longo do eixo x em um grau.

func (*TransformFunctions) SkewY 

func (el *TransformFunctions) SkewY(a float64) (ref *TransformFunctions)

SkewY

English:

The skewY(<a>) transform function specifies a skew transformation along the y axis by a degrees.

Português:

A função de transformação skewY(<a>) especifica uma transformação de inclinação ao longo do eixo y em um grau.

func (TransformFunctions) String 

func (el TransformFunctions) String() string

func (*TransformFunctions) Translate 

func (el *TransformFunctions) Translate(x, y float64) (ref *TransformFunctions)

Translate

English:

The translate(<x> [<y>]) transform function moves the object by x and y. If y is not provided, it is assumed to be 0.

In other words: 

xnew = xold + <x>
ynew = yold + <y>

Português:

A função transform translate(<x> [<y>]) move o objeto em x e y. Se y não for fornecido, assume-se que é 0.

Em outras palavras: 

xnew = xold + <x>
ynew = yold + <y>

type Translate 

type Translate string
const (
	// KTranslateYes
	//
	// English:
	//
	//  The translate attribute specifies whether the content of an element should be translated.
	//
	// Português:
	//
	//  O atributo translate especifica se o conteúdo de um elemento deve ser traduzido.
	KTranslateYes Translate = "yes"

	// KTranslateNo
	//
	// English:
	//
	//  The translate attribute specifies whether the content of an element should not be translated.
	//
	// Português:
	//
	//  O atributo translate especifica se o conteúdo de um elemento não deve ser traduzido.
	KTranslateNo Translate = "no"
)

func (Translate) String 

func (e Translate) String() (element string)

type Warp 

type Warp string
const (
	// KWarpHard
	//
	// English:
	//
	//  The browser automatically inserts line breaks (CR+LF) so that each line has no more than the
	//  width of the control;
	//
	//   Note:
	//     * The cols attribute must also be specified for this to take effect.
	//
	// Português:
	//
	//  O navegador insere automaticamente quebras de linha (CR+LF) para que cada linha não tenha mais
	//  que a largura do controle;
	//
	//   Nota:
	//     * O atributo cols também deve ser especificado para que tenha efeito.
	KWarpHard Warp = "hard"

	// KWarpSoft
	//
	// English:
	//
	//  The browser ensures that all line breaks in the value consist of a CR+LF pair, but does not
	//  insert any additional line breaks.
	//
	// Português:
	//
	//  O navegador garante que todas as quebras de linha no valor consistam em um par CR+LF, mas não
	//  insere nenhuma quebra de linha adicional.
	KWarpSoft Warp = "soft"

	// KWarpOff
	//
	// English:
	//
	//  Like soft but changes appearance to white-space: pre so line segments exceeding cols are not
	//  wrapped and the <textarea> becomes horizontally scrollable.
	//
	//   Note:
	//     * Non-Standard
	//
	// Português:
	//
	//  Como soft, mas altera a aparência para espaço em branco: antes disso, os segmentos de linha que
	//  excedem as colunas não são quebrados e a <textarea> torna-se rolável horizontalmente.
	//
	//   Nota:
	//     * Não-Padrão
	KWarpOff Warp = "off"
)

func (Warp) String 

func (e Warp) String() string

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.